python自动开发，基础2

python自动开发，基础2

测试环境：

IDLE (Python 3.8 64-bit)

os：win7

1、什么是pyc？（了解）

PyC（Python Compiled File）是Python编译后的字节码文件的扩展名，它是由Python解释器将源代码文件（.py）编译为字节码形式而生成的文件。在运行Python程序时，解释器会首先检查是否存在对应的.pyc文件，如果存在且比源代码文件更加新，则会加载并执行.pyc文件，从而提高程序的执行效率。

.pyc文件包含了源代码文件的字节码形式，这样在下次运行相同程序时，解释器可以直接加载.pyc文件，而不需要再次编译源代码文件，从而减少了启动时间。因此，.pyc文件主要用于缓存已编译的字节码，提升程序的执行速度。

Python解释器会自动管理.pyc文件的生成和使用过程，当源代码文件被修改后，对应的.pyc文件也会被更新。

总结：.pyc文件是Python编译后的字节码文件，它提供了一种优化执行速度的机制。

2、python数据类型

常见的Python数据类型：（标红表示重点，用的最多）

1. 整数（int）：代表整数值，如 1、2、-10 等。
2. 浮点数（float）：代表带有小数部分的数值，如 3.14、2.5 等。
3. 字符串（str）：代表文本值，用单引号或双引号括起来，如 ‘hello’、“world” 等。
4. 列表（list）：有序可变序列，包含多个元素，用方括号括起来，如 [1, 2, 3]、[‘apple’, ‘banana’, ‘orange’] 等。
5. 元组（tuple）：有序不可变序列，类似于列表，但元素不能修改，用圆括号括起来，如 (1, 2, 3)、(‘apple’, ‘banana’, ‘orange’) 等。
6. 集合（set）：无序、不重复的集合，用花括号或 set() 函数创建，如 {1, 2, 3}、{‘apple’, ‘banana’, ‘orange’} 等。
7. 字典（dict）：无序键值对集合，每个键对应一个值，用花括号或 dict() 函数创建，如 {‘name’: ‘Alice’, ‘age’: 25} 等。
8. 布尔值（bool）：代表真（True）或假（False）的值。

3、列表

列表概述：列表是一种用于存储多个元素的有序、可变的数据结构。

3.1、创建列表

使用方括号 [] 或 list() 函数来创建一个空列表，或在方括号中使用逗号分隔的元素来初始化一个列表。

empty_list = []
numbers = [1, 2, 3, 4, 5]

3.2访问元素

使用索引值来访问列表中的元素。索引从 0 开始，可以使用负数索引从列表的末尾开始倒序访问。

first_element = numbers[0]     # 访问第一个元素
last_element = numbers[-1]     # 访问最后一个元素

3.3修改元素

通过索引值重新赋值来修改列表中的元素。

numbers[0] = 10   # 将第一个元素修改为 10

3.4添加元素

使用 append() 方法在列表末尾添加一个元素，使用 insert() 方法在指定位置插入一个元素。

numbers.append(6)       # 在列表末尾添加元素 6
numbers.insert(2, 7)    # 在索引为 2 的位置插入元素 7

3.5移除元素

使用 remove() 方法根据元素的值来移除一个元素，使用 pop() 方法根据索引值来移除一个元素。

numbers.remove(3)    # 移除值为 3 的元素
numbers.pop(1)       # 移除索引为 1 的元素

还有一种方法是采用del删除方式

del numbers[1]  # 移除索引为 1 的元素

3.6列表长度

使用 len() 函数获取列表中元素的个数。

length = len(numbers)   # 获取 numbers 列表的长度

3.7切片

使用切片操作可以获取列表的子列表。切片操作使用开始索引、结束索引和步长来指定需要获取的元素范围。

sublist = numbers[1:4]     # 获取索引从 1 到 3 的元素（不包括索引 4）

3.8列表合并

使用 + 运算符将两个列表合并为一个新的列表，或者采用extend。

#+
combined_list = numbers + [6, 7, 8]


#extend
numbers2 = [1,2,3,4]
numbers.extend(numbers2)

3.9列表方法

列表还有其他很多有用的方法，如 sort() 对列表进行排序，reverse() 反转列表，count() 统计某个元素在列表中出现的次数，通过索引 index来查找需要找的内容的位置 等。

numbers.sort()                # 对列表进行升序排序
reversed_numbers = numbers[::-1]   # 反转列表
count_of_2 = numbers.count(2)  # 统计元素 2 在列表中出现的次数

print(numbers.index("xxx"))   #xxx为需要找的内容，输出内容所在列表的路径

3.10 列表复制

copy() 是用于创建列表（或其他可变对象）的浅拷贝的方法。浅拷贝会创建一个新的对象，该对象与原始对象具有相同的元素，但是它们指向不同的内存地址。这意味着修改原始对象或复制对象中的元素不会相互影响。

下面是使用 copy() 方法进行浅拷贝的示例：

#/usr/bin/evn python
numbers = [1, 2, 3, 4, 5]
copy_numbers = numbers.copy()

print(numbers)       # 输出: [1, 2, 3, 4, 5]
print(copy_numbers)  # 输出: [1, 2, 3, 4, 5]

# 修改原始列表的第一个元素
numbers[0] = 10

print(numbers)       # 输出: [10, 2, 3, 4, 5]
print(copy_numbers)  # 输出: [1, 2, 3, 4, 5]

在上面的示例中，通过调用 copy() 方法创建了一个新的列表 copy_numbers，它与原始列表 numbers 具有相同的元素。然后，我们将原始列表的第一个元素修改为 10，但是复制的列表并没有受到影响。

需要注意的是，copy() 方法执行的是浅拷贝，也就是说，如果列表中包含其他可变对象（如嵌套列表或字典），那么这些对象仍然会被引用，而不会被复制。这种情况下，修改嵌套对象可能会对原始列表和复制列表产生影响。

例如：

#/usr/bin/evn python
original_list = [1, 2, [3, 4]]
copied_list = original_list.copy()

print(original_list)  # 输出: [1, 2, [3, 4]]
print(copied_list)    # 输出: [1, 2, [3, 4]]

# 修改嵌套列表的值
original_list[2][0] = 5

print(original_list)  # 输出: [1, 2, [5, 4]]
print(copied_list)    # 输出: [1, 2, [5, 4]]

#其两个都会改变

如果需要进行深拷贝，也就是创建一个完全独立的对象副本，可以使用 copy 模块中的 deepcopy() 方法。深拷贝会递归地复制所有嵌套对象，从而创建一个完全独立的副本。

#/usr/bin/evn python
import copy     #需要调用一个模块

numbers = [1, 2, [3, 4, 5]]
copy_numbers = copy.deepcopy(numbers)

numbers[2][0] = 10

print(numbers)       # 输出: [1, 2, [10, 4, 5]]
print(copy_numbers)  # 输出: [1, 2, [3, 4, 5]]

在上面的示例中，使用 deepcopy() 方法创建了一个完全独立的副本 copy_numbers，即使修改了嵌套的子列表，原始列表和复制列表中的子列表仍然是独立的。

3.11 循环使用

上一节中，循环是可以是条件，也可以是参数步长，现在是列表进行循环

#/usr/bin/evn python
numbers = [1, 2, 3, 4, 5]

for i in numbers:
	print(i)
	
#将会将列表中的数据一个个输出出来

拓展：python中含有一个内置的函数 enumerate 其可以将列表中的索引和内容显示出来

fruits = ['apple', 'banana', 'orange']

for index, fruit in enumerate(fruits):
    print(index, fruit)

输出为：

0 apple
1 banana
2 orange

4、元组

元组也是一个列表，只读列表，一旦创建则不会改变

语法：

name = ("kd","jack","kunkun")  #小括号

使用方法：

count统计和index查找两种方法

应用：用于不能更改的数据。

5、字符串的用法

字符串常见方法：

• lower() 和 upper()：将字符串分别转换为小写和大写形式。
• strip()：去除字符串两端的空白字符。
• split()：将字符串按指定分隔符拆分成列表。
• replace()：替换字符串中的子串。
• startswith() 和 endswith()：判断字符串是否以指定的前缀或后缀开头/结尾。

可以查阅Python官方文档或其他参考资料来深入了解更多的字符串操作和用法。

也可以在python的编译器上：

name = "kd"
name.                     #点之后会列出各个字符串的用法，可以一一去尝试

lower() 和 upper()：将字符串分别转换为小写和大写形式。

text = "Hello, World!"
print(text.lower())  # 输出: hello, world!
print(text.upper())  # 输出: HELLO, WORLD!

strip()：去除字符串两端的空白字符。

text = "   Hello, World!   "
print(text.strip())  # 输出: "Hello, World!"

split()：将字符串按指定分隔符拆分成列表。

text = "apple,banana,orange"
fruits = text.split(",")
print(fruits)  # 输出: ['apple', 'banana', 'orange']

replace()：替换字符串中的子串。

text = "Hello, World!"
new_text = text.replace("Hello", "Hi")
print(new_text)  # 输出: Hi, World!

startswith() 和 endswith()：判断字符串是否以指定的前缀或后缀开头/结尾。

text = "Hello, World!"
print(text.startswith("Hello"))  # 输出: True
print(text.endswith("!"))  # 输出: True

6、字典

以键值对的方式存在。

key：value

增加（添加）键值对：

使用赋值操作符（=）可以添加新的键值对，如果键不存在，则创建一个新的键值对。

my_dict = {}

# 添加键值对
my_dict['name'] = 'Alice'
my_dict['age'] = 25

print(my_dict)  # 输出: {'name': 'Alice', 'age': 25}

删除键值对：

使用 del 关键字可以删除指定的键值对。使用 pop() 方法可以返回并删除指定键的值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 删除指定的键值对
del my_dict['age']
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}

# 返回并删除指定键的值
city = my_dict.pop('city')
print(city)  # 输出: 'New York'
print(my_dict)  # 输出: {'name': 'Alice'}

修改键值对：

使用赋值操作符（=）可以修改指定键的值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 修改指定键的值
my_dict['age'] = 30
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}

查询键值对：

使用键可以直接查询对应的值。使用 get() 方法可以查询指定键的值，并且可以设置默认值以防止键不存在时引发 KeyError 异常。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 查询指定键的值
name = my_dict['name']
print(name)  # 输出: 'Alice'

# 查询指定键的值，设置默认值
country = my_dict.get('country', 'Unknown')
print(country)  # 输出: 'Unknown'

多级字典的嵌套使用：（重点）

字典中的值也可以是字典，从而实现多级字典的嵌套使用。可以通过多次键的索引来访问和修改多级字典中的值。

my_dict = {'person': {'name': 'Alice', 'age': 25, 'city': 'New York'}}

# 访问多级字典中的值
name = my_dict['person']['name']
print(name)  # 输出: 'Alice'

# 修改多级字典中的值
my_dict['person']['age'] = 30
print(my_dict)  # 输出: {'person': {'name': 'Alice', 'age': 30, 'city': 'New York'}}

字典转换成列表：

# 转换为包含所有键值对的列表

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

items = list(my_dict.items())
print(items)  # 输出: [('name', 'Alice'), ('age', 25), ('city', 'New York')]

简单购物列表示例：

题目，输入你的工资，得到一个一个购物清单，选择需要的购物商品，选择完成后工资跟着变化，如果工资不够，会有提示，
选择退出后，可以得到你所购买的商品以及你的剩余的金额。

给出下列商品
'Iphone', 4999
'Mac Pro', 4577
'Bike', 800
'Watch', 2000
'Coffee', 31
'Alex Python', 120
'Shirt', 200
'Headphones', 1500

代码解析：

product_list = [
    ('Iphone', 5800),
    ('Mac Pro', 9800),
    ('Bike', 800),
    ('Watch', 10600),
    ('Coffee', 31),
    ('Alex Python', 120),
    ('Shirt', 200),
    ('Headphones', 1500)
]   #创建列表

shopping_list = []  # 购物车列表，用于存储用户购买的商品
salary = input("请输入您的工资：")  # 输入工资金额
if salary.isdigit():  # 判断输入的工资是否为数字
    salary = int(salary)  # 将工资转换为整型
    while True:
        for index, item in enumerate(product_list):
            # 输出商品编号及商品信息
            print(index, item)
        user_choice = input("请选择要购买的商品编号（输入 'q' 退出）：>>>")
        if user_choice.isdigit():  # 判断用户输入是否为数字
            user_choice = int(user_choice)  # 将用户选择转换为整型
            if 0 <= user_choice < len(product_list):  # 判断用户选择的商品编号是否有效
                p_item = product_list[user_choice]  # 获取用户选择的商品信息
                if p_item[1] <= salary:  # 判断余额是否足够支付所选商品
                    shopping_list.append(p_item)  # 将商品加入购物车列表
                    salary -= p_item[1]  # 更新余额
                    print("已将 %s 加入购物车，您当前的余额为 \033[31;1m%s\033[0m" % (p_item, salary))
                else:
                    print("\033[41;1m您的余额只剩[%s]啦，无法继续购买\033[0m" % salary)
            else:
                print("商品编号 [%s] 不存在！" % user_choice)
        elif user_choice == 'q':  # 用户选择退出
            print("-------- 购物清单 --------")
            for p in shopping_list:
                print(p)
            print("您当前的余额为：", salary)
            exit()
        else:
            print("无效的选项")

the end