同C一样，python 中如果要对文件进行操作，也需要先打开文件，操作完关闭文件。python中打开文件的函数为 open 函，关闭文件的函数为 close 。

open 函数的第一个参数为要写入文件的路径，第二个参数为对文件进行读写的模式。
print 函数的第一个参数是要写入的数据内容，第二个参数是要写入的文件对象。
下表为文件操作的一些常用模式

如下图，打开 D 盘中的 text.txt 文件，即可看到写入的 hello world。

2.数据类型、基本操作符与注释

python 中的数据类型分为 4 类，整型，浮点型，布尔型，字符串。

整型、浮点型就不必多说了，和C完全相同。而python的布尔类型则是对真假的判断，True 为真，False 为假，并且他们True 的值默认为1，False 的值默认为0。
除了以下图片里的布尔值为False，其余均为True

字符串类型是不可变类型，可以用单引号、双引号，多引号来定义，其中单、双引号定义的字符串都必须在同一行，三引号定义的字符串可以在一行或者多行，如下图。 

不同类型的数据如果要一起使用必须转化为同一种类型，浮点数和整形会自动将结果转化为浮点型数据，其他的类型在可转化的前提下可以使用类型转化函数将数据进行类型转化。

2.2 基本操作符

算数操作符中，最基本的加减乘、取模都与C相同。不同的是python中进行了除法分类，并加入了幂运算符。
python 将除法分为了整数除法（//）和普通除法（/），而整数除法就是向下取整，大家应该懂的，和C一样，而普通除法可以进行正常的运算，两个整数相除也可以得到浮点数。
幂运算符（**）前面的操作数是幂运算的底数，后面的操作数是幂运算的次数。
 

2.22 逻辑操作符

逻辑与and、逻辑或or、逻辑非not，分别对应C语言中的&&，||，！运算符。
而 in 则是用于判断一个元素是否在一个容器中，具体来说，可以用于判断元素是否在列表、字符串、元组、集合、字典中，not in 正好相反，是判断元素是否不在容器中。

2.23 位操作符及操作符优先级

python的位操作符与C是一样的，有& 按位与 ，| 按位或， ^ 按位异或， ~ 按位取反，<< 左移， >>右移。具体方法与C中是一样的，这里就不过多赘述。
操作符的优先级
严格按照下面的优先级进行运算，如果不确定或者要先计算优先级低的运算记得加括号。

2.3 注释

python的注释方式也进行了改变，注释方式改为在语句前加 # 号
在 PyCharm 中，对多段语句进行整体注释方式是 Ctrl+ /

3.数据的存储

python存储数据的逻辑图

每个数据都有自己的 id，而变量中存储的仅仅是这个数据的 id，编译器通过这个 id 就找到了这块的数据，进而进行一系列操作，这里的 id 类似于C中的地址，而这样的访问方式类似于指针。
可以用 is 来比较两个变量的 id 时候相等

 返回True，说明变量 a 和 b 访问是同一块内存空间，完全相等。
在C中，数据会被存储到多个区域中，如堆区，栈区等等，下图为C中数据存储的区域

python中也有大量的区域供使用者存储数据

栈区：存储基本数据类型及其对象（如int、float、bool等），以及函数调用时的参数、返回值和局部变量等。栈内存自动分配和释放，具有快速的存取速度。
堆区：存储复杂对象（如列表、元组、字典等）及其对象。堆内存的分配与释放由Python解释器自动进行，可以通过Python中的垃圾回收机制自动释放内存。
数据区：存储全局变量和静态变量，以及常量等数据。
代码区：存储Python的字节码，即转换成机器码之前的中间代码。

在C中，需要手动分配和释放动态内存，而在Python中，内存管理是自动的，Python解释器会根据需要自动分配和释放内存。

4.分支和循环

分支和循环这里与C语言大同小异，逻辑上大同，语法规则上小异。

4.1 分支语句 if-else

python语法如下，与C相比，只是去掉了括号，如果if中包含多条语句，则可使用相同的缩进来代替C中的大括号。

if condition:
    # code to be executed if condition is True
else:
    # code to be executed if condition is False

其中，condition是一个表达式，如果结果为True，代码块1就会被执行，否则代码块2就会被执行。
下面是一个示例：

下面是一个示例：

a = 10
if a > 0:
    print("a is positive")
else:
    print("a is not positive")

python 将 else if改成了elif 语句，用于添加多个条件分支。

条件表达式
python中的条件表达式类似于C语言中的三目操作符
例如，以下代码用条件表达式来检查变量x是否大于5，如果是，则将变量y的值设置为10，否则将其设置为0：

x = 7
y = 10 if x > 5 else 0
print(y)  # 输出 10

在这个例子中，条件表达式的条件是“x > 5”，如果为True，则返回值为10（即“y = 10”），否则返回值为0（即“y = 0”）。但这种条件表达式只适用于较为简单的分支情况，更复杂的条件逻辑，应该使用 if 语句来代替。

4.2 循环

while循环基本与C是一样的，一直循环某种结构，直到满足特定的条件为止。

while 条件:
    循环体

代码示例

i = 0
while i < 5:
    print(i)
    i += 1

Python中的for-in循环用于迭代遍历序列或集合中的每个元素。

for 变量名 in 序列:
    循环体语句

其中，变量名是循环变量，用于在循环中引用每个元素，序列可以是列表、元组、字符串、集合或字典等可迭代对象，循环体语句是需要重复执行的语句块
示例代码：

names = ['Alice', 'Bob', 'Charlie', 'David']
for name in names:
    print(name)

# 输出结果：
# Alice
# Bob
# Charlie
# David

在循环体中可以结合条件语句，实现更加灵活的控制流程。

4.3 pass语句

pass是一个空语句，它不执行任何操作。但它可以被用作占位符，表示"在这里不做任何事情"，通常可以帮助我们搭建语法结构，因为Python需要在代码块中有至少一个语句。例如，当你想要先写下一些代码的框架但还没有想好实现时，可以在代码块中使用pass语句占位。

def my_function():
    pass

在上面的代码中，my_function 函数中没有任何操作，但由于使用了 pass 语句，它仍然可以正确地定义。如果没有 pass 语句，代码将会报错。

5.python基础数据结构

python的基础数据结构有字符串、元组、列表、字典、集合五种。

元组、字符串是不可变序列，自身不能进行增删查改等操作。
有序数列是有下标的
1.下标及索引规则
下标可以从前开始，也可以从后开始
从前开始的规则是从0 开始，依次递增1
从后开始的规则是从-1开始，依次递减1

5.1列表——python中的数组

在Python中，与C语言中的数组相对应的数据类型是列表（list）。列表可以用于存储多个元素，并且可以动态地增加或减少元素的个数。和数组类似，列表的元素可以通过索引访问，也可以使用循环遍历所有元素。但是，相比于数组，在Python中使用列表更为方便和灵活。
列表的创建
用一对方括号[]来表示一个空列表，或者在方括号内添加逗号分隔的值列表即可创建一个有元素的列表；还可以使用list()函数来创建一个列表：在list函数内放置多个值，如果是字符串，会将中每个字符单独作为元素。

5.1.1 列表的增删查改

列表中查询元素
在列表中查询列表元素有两种方法：第一种是列表名[索引]，下标从0开始，第一个元素的索引为0，最后一个元素的索引为列表元素总数 sz-1；还可以‘倒着’索引：最后一个元素的索引为 -1，第一个元素的索引为sz，当然这两种索引的下标都是从小到大。
第二种是index(列表元素)，可用于查找列表中某个元素第一次出现的位置，其基本语法如下：

list.index(x[, start[, end]])

其中，x 是需要查找的元素；start 和 end 是可选参数，表示查找的起始位置和结束位置，如果省略则默认查找整个列表。
如果该元素不存在于列表中，则会引发ValueError异常，可以使用try-except语句来避免程序崩溃。例如下面代码：

my_list = [1, 2, 3, 4, 5]
try:
    index = my_list.index(6)
    print(index)
except ValueError:
    print("Element not found in list")

下面是关于 try-except 语句的说明：

try 块：try 块包含可能会引发异常的代码。当在 try 块中的代码引发异常时，Python会停止执行 try 块内的代码，并跳转到 except 块，从而防止异常传播到程序的其他部分。

try-except 语句允许你在代码中处理异常，使程序能够更加健壮，能够应对潜在的错误情况，并在异常发生时执行适当的处理代码。这有助于提高程序的可靠性和稳定性。

增加元素
可以使用append()方法将一个元素添加到列表的末尾。也可以使用extend()方法将另一个列表的元素添加到当前列表的末尾，或者使用insert()方法将元素插入到指定的位置。

my_list = [1, 2, 3]
my_list.append(4)  #将一个元素添加到列表的末尾
print(my_list)  # [1, 2, 3, 4]
my_list = [1, 2, 3]
my_list.extend([4, 5])  #另一个列表的元素添加到当前列表的末尾
print(my_list)  # [1, 2, 3, 4, 5]
my_list = [1, 2, 3]
my_list.insert(1, 4)   #将元素插入到指定的位置
print(my_list)  # [1, 4, 2, 3]

删除元素
可以使用remove()方法删除指定的元素，还可以使用pop函数删除列表中指定位置的元素，或者使用del语句删除指定位置上的元素。

my_list = [1, 2, 3]
my_list.remove(2) #删除列表中的 2 元素
print(my_list)  # [1, 3]
my_list = [1, 2, 3]
my_list.pop(0) # 删除并返回1
print(my_list) # 输出[2,3]
my_list = [1, 2, 3]
del my_list[1] #删除索引1位置的元素
print(my_list)  # [1, 3]

修改元素
可以直接通过下标来修改指定位置上的元素。

my_list = [1, 2, 3]
my_list[1] = 4  #将索引1位置处的元素改为4
print(my_list)  # [1, 4, 3]

5.1.2 对列表进行其他操作

创建列表的副本

列表的副本是创建了一个新的列表，它包含与原始列表相同的元素，但实际上是一个不同的对象。因此，对副本所做的更改不会影响原始列表。 创建副本有下面几种方法

1.使用切片操作符[:]。例如，如果原列表是my_list，可以使用my_list[:]来创建一个副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = my_list[:]

2.使用copy()方法。例如，如果原列表是my_list，可以使用my_list.copy()来创建一个副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = my_list.copy()

3.使用list()函数。例如，如果原列表是my_list，可以使用list(my_list)来创建一个副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = list(my_list)

对列表进行排序
在C语言中，如果我们要对数组元素进行排序，可能要使用冒泡排序、qsort排序等方法，而在python列表中，有专门的函数对列表进行排序。
降序排列

my_list = [3,1,4,1,5,9,2,6,5,3,5]
my_list.sort(reverse=True)
print(my_list)

升序排列

my_list = [3,1,4,1,5,9,2,6,5,3,5]
my_list.sort()
print(my_list)

求某元素在列表中出现的次数

第一种方法是对列表进行遍历，设立一个计数器，当出现某元素的时候，count就加1。

# 使用for循环遍历列表，并在出现元素 x 时计数器加1
for item in lst:
    if item == x:
        count += 1

# 输出结果
print(count)

也可以使用python的内置函数count来统计

# 使用列表的内置方法count来统计元素 x 的出现次数
count = lst.count(x)

# 输出结果
print(count)

5.2 字典——python中的结构体

Python字典是一种无序的集合数据类型，它由一系列键值对组成，每个键值对之间用逗号分隔。字典中的键必须是唯一的，而值可以是任何类型的数据。字典是Python语言中常用的一种数据结构，可以直接使用，不需要定义或声明，并且它提供了灵活的数据组织和访问方式：直接通过键就可以访问键对应的值。

字典的创建方式：
1、使用花括号{}，用冒号分割键值： dict1 = {'key1': 'value1', 'key2': 'value2', ...}，key与value是一一对应的。
2、使用内置函数dict()函数创建：dict2 = dict(key1='value1', key2='value2', ...)
3、使用dict.fromkeys()方法创建，键可以输入多种，而值只能是一种：dict3 =dict.fromkeys(['key1', 'key2', ...]，100)
4、创建空字典：直接使用花括号{}，里面不放值；使用dict()函数里面不放值。
字典定义示例：

person = {
    "name": "John",
    "age": 30,
    "city": "New York"}

其中，键分别是"name"、“age"和"city”，对应的值分别是"John"、30和"New York"。可以通过键来访问对应的值。例如：

print(person["name"])  # 输出：John
print(person["age"])   # 输出：30

字典的内存是由python解释器自动管理内存的，在使用过程中不需要考虑内存分配和释放的问题。

5.2.1 字典常用的操作

获取字典中的值：通过键来获取字典中的值，例如 dict[key]。

添加新键值对：使用 dict[key] = value，可以向字典中添加新的键值对。

修改键值对：通过键来修改字典中的值，例如 dict[key] = new_value。

删除键值对：使用 del dict[key] 可以删除字典中的键值对。

获取字典的长度：使用 len(dict) 可以获取字典中键值对的数量。

判断键是否存在：可以使用 in 关键字判断一个键是否存在于字典中，例如 key in dict。

获取所有键或所有值：使用 dict.keys() 可以获取字典中所有的键，使用 dict.values() 可以获取字典中所有的值。

获取所有键值对：使用 dict.items() 可以获取字典中所有的键值对。

清空字典：使用 dict.clear() 可以清空整个字典。

复制字典：使用 dict.copy() 可以复制一个字典。

5.2.2 字典的特点

字典是无序的：字典中的条目没有固定的顺序，存储的顺序与定义时候的顺序无关。
字典是可变的：可以添加、删除或修改字典中的键值对。
字典中的键必须是不可变的类型，例如整数、浮点数、字符串或元组，而值可以是任何类型。
每个键只能在字典中出现一次，如果同一个键被多次赋值，则只有最后一个值被保留。
字典通常用于快速查找和检索，可以根据键快速访问值，时间复杂度为O(1)。
字典的存储是’随机的’，依靠键来找值，因此浪费了大量的内存，是一种以空间换时间的数据结构。

5.3 元组

元组是python内置的数据结构之一，是一个不可变序列，可以包含任意类型的数据，如数字、字符串、列表、字典、元组等。

元组的创建
1、使用小括号()将元素括起来，用逗号分隔，例如：

(1,"hello",[3,4],5.6,{"帅哥":"打篮球"})

2、使用内置函数 tuple()，将列表或者其他迭代对象转化为元组，如 t=tuple([1,2,3])
3、可以省略小括号，逗号分隔的情况下直接创建元组，例如：t=1,“hello”,[3,4],5.6
4、只有一个元素是，加逗号以区分元组和表达式，例如：t=(1,)
5、空元组：()或者 t = tuple()

为什么要将元组设置为不可变序列？
元组被设计为不可变序列，因为它们可以用来表示一组不可变的数据，例如日期、时间、坐标等。一旦元组被创建，它们的值就不能被修改，这使得它们比可变序列更安全，因为它们不能被意外修改。此外，元组也比列表更加高效，因为它们的不可变性使得在处理大量数据时，它们能够更快速地被创建、操作和释放。

5.4 集合

集合是一种python内置的数据结构，与列表、字典一样都属于可变类型的序列，并且集合里的元素是无序不重复的，所以集合相当于没有value的字典。
字典的创建

• 直接{}，例如s = {‘python’, ‘hello’ , 90}
• 使用内置函数set()，括号里面可以包含多种数据类型的元素

创建空集合也需要使用set()函数，如果直接用大括号初始化空集合会被解释器认为是空字典。

5.4.1集合常用的操作

集合元素的新增

• add()：添加单个元素到集合中
• update()：添加多个元素到集合中

add()方法示例

# 定义一个空集合
my_set = set()
# 添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)
print(my_set)  # 输出：{1, 2, 3}

update()方法示例

# 定义一个空集合
my_set = set()
# 添加元素
my_set.update([1, 2, 3])
my_set.update([4, 5, 6])
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6}

集合元素的删除

• remove()：按照元素值删除一个元素，如果元素不存在，就触发KeyError
• discard()：按照元素值删除一个元素，如果元素不存在，不报错
• pop()：随机删除集合中一个元素，并返回该元素，集合为空则触发KeyError
• clear()：删除集合中所有元素

  s=set(range(1,6))
  print(s) #{1,2,3,4,5}
  s.pop()  #随机删除一个
  print(s) # {2,3,4,5}   
  s.discard(3) #删除集合元素 3
  print(s)  #{2, 4, 5}
  s.clear() #清空
  print(s) #输出空集合

判断两个集合的关系

• issubset()——s2.issubset(s1)，判断s2是否是s1的子集
• issuperset()——s1.issuperset(s2)，判断s1是否是s2的超集
• isdisjoint()——s1.isdisjoint(s2)，判断s1和s2是否没交集

求两个集合交并集的方法

• intersection——s1.intersection(s2)，等价于 s1&s2，求s1与s2的交集
• union——s1.union(s2)，等价于 s1| s2，求s1与s2的并集
• difference——s1.difference(s2)，等价于s1-s2，求s1与s2的差集
• symmetric_difference——s1.symmetric_difference(s2)，等价于 s1^s2，求s1与s2的对称差集（并集 - 交集）
   

5.5 字符串

5.51 字符串常用操作

字符串查询

• index()，在字符串中查找指定字符串，返回首次出现时候的索引，找不到就报错。
• find()，在字符串中查找指定字符串，返回首次出现时候的索引，找不到则返回-1
• rindex()，在字符串中查找指定字符串，返回最后一次出现时候的索引，找不到就报错
• rfind()，在字符串中查找指定字符串，返回最后一次出现时候的索引，找不到就返回-1

字符串大小写转化

• upper()——将字符串中所有字符都转化为大写字母
• lower()——将字符串中所有字符都转化为小写字母
• swapcase()——把字符串所有的大写转化为小写，小写转化为大写
• capitalize()——把第一个字母转化为大写，其余字母转为小写
• title()——把每个单词的第一个字母转化为大写，把每个单词的剩余字符转化为小写。

字符串对齐
字符串内容对齐是指将字符串中的内容按照一定的方式对齐，使其更加美观，易于阅读，并且符合视觉习惯。常见的字符串内容对齐操作包括左对齐、右对齐、居中对齐等。
若传递的字符串宽度 width 小于字符串长度，则返回字符串包本身

• ljust()——左对齐

txt = txt.ljust(width,fillchar)

其中，width表示字符串的总宽度；fillchar表示要填充的字符，默认为空格。如果字符串长度小于width，则用fillchar在右侧填充，直到达到width长度。

• rjust——右对齐

string.rjust(width, fillchar)

其中，width表示字符串的总宽度；fillchar表示要填充的字符，默认为空格。如果字符串长度小于width，则用fillchar在左侧填充，直到达到width长度

• zfill——右对齐（用0填充）

string.zfill(width)

右对齐，只接收一个参数，用于指定字符串对齐的宽度

• center——居中对齐

string.center(width,fillchar)

其中，width表示字符串的总宽度；fillchar表示要填充的字符，默认为空格。如果字符串长度小于width，则用fillchar在左右两侧均匀填充，直到达到width长度

字符串劈分
字符串劈分操作是指根据指定的分隔符将一个字符串拆分成多个子字符串。

• splist(sep=,maxsplit)，从字符串左边开始劈分，sep 是劈分字符，maxsplit 是劈分的最大次数
• rsplit(sep=,maxsplit)，从字符串右边开始劈分，sep 是劈分字符，maxsplit 是劈分的最大次数

在经过最大劈分次数后，剩余的子串将会单独作为一部分。
判断字符串的方法

• isidentifier()，判断字符串是不是合法的标识符
• isspace()，判断字符串是否全部由空白字符组成（回车、换行、水平制表符等）
• isalpha()，判断指定的字符串是否全部由字母组成（汉字也算字母）
• isdecimal()，判断字符串是否全部由十进制数字组成
• isnumeric()，判断指定的字符串是否全部由数字组成（Unicode编码中的数字字符）
• isalnum()，判断指定字符串是否全部由字母和数字组成

isnumeric函数可以判断Unicode编码中的数字字符是否是数字，包括阿拉伯数字0-9、罗马数字、中文数字、泰语数字、藏文数字等，但 isnumeric函数 不能判断小数、负数、科学计数法等特殊的数字形式。

字符串替换

• replace()，第一个参数是被替换的字符串的子串，第二个参数是替换的字符串，第三个参数是最大替换次数，函数返回替换后的字符串，原字符串不变，如果未找到子串，则不进行替换。
• join()，用于将一个可迭代对象（如list、tuple等）中的元素用某字符连接成一个字符串。

separator = ' '  # 连接符（可以为任意字符）
seq = ['apple', 'banana', 'cherry']   # 可迭代对象，如果只有一个字符串，就默认字符串本身为可迭代对象
result = separator.join(seq)   # 将seq中每个元素用separator连接起来
print(result)  # 输出 'apple banana cherry'

5.52 字符串的比较及字符的Unicode编码

字符的Unicode编码
每个字符都有对应的Unicode编码，类似于C语言中的ASCII码，但更全面。Unicode编码的前128个就是ASCII，并且Unicode编码为所有字符都设立的编码，更全面。

• ord()，ord函数可以将一个字符转化为其对应的 Unicode编码。
• chr()，chr函数可以将Unicode编码转化为对应的字符。

字符串的比较
先比较两个字符串中的第一个字符的Unicode编码，如果相等，则继续比较下一个字符，依次比较下去，直到两个字符不相等，其比较结果就是两个字符串的比较结果，后续字符串中的字符将不再被比较。
字符串相等 is ，比较的是两个字符串的地址（id）是否相等；而字符串相等 ==，比较的是两个字符串的值（value）是否相等。

5.53 格式化字符串

为什么要格式化字符串？

如图，这就是一种‘格式化’，需要改的地方只有 xxx 的部分，极大提高了工作效率。
格式化字符串的方式

例如：

5.54 字符串的编码转化

为什么要进行字符串的编码转化

传输数据：在网络传输和存储中，需要将字符串编码转换为字节流的形式。例如，使用 HTTP 请求和响应传输数据时，需要将数据转换为 UTF-8 或其他编码格式的字节流。

多语言支持：不同语言使用不同的编码方式，进行编码转换可以确保在不同语言之间传输数据时不会出现乱码。

安全性：某些字符可能被用于编写恶意代码或注入攻击，进行编码转换可以保障系统的安全性。

数据库操作：在将数据存储到数据库中时，可能需要将字符串进行编码转换，以确保数据库支持该编码格式并且能正确存储和检索数据。

业务需求：有时候，业务需求需要将字符串转换为指定的编码格式，以满足特定场景的要求。例如在一些人工智能领域中，需要将文本进行编码转换以方便进行文本分析和处理。

• 编码：s.encode(ending=‘GBK’) 或者 s.encode(ending=‘UFT-8’)，将字符串s转化为二进制数据
• 解码：s.decode(ending=‘GBK’) 或者 s.decode(ending=‘UFT-8’)，将二进制数据转化为字符

编和解的字节流必须统一，如用’GBK’编码，就必须使用’GBK’解码，使用’UFT-8’编码就必须使用’UFT-8’解码。

5.6 生成式合集

5.6.1 字典生成式
 

内置函数zip():用于将迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。

字典生成式语法格式：

{key: value for key, value in iterable}

其中，key表示字典的键，value表示字典的值，iterable表示可迭代对象，例如列表、元组、字典等。生成式会遍历iterable中的每个元素，根据指定的规则创建一个新的字典。

假设我们有两个列表，先使用 zip 函数将对应元素打包为元组再返回

items=['Fruits','Book','Others']
prices=[96,78,85]
lst=zip(items,prices)

再使用字典生成式生成一个键值对应的字典

d = {items:prices for items,prices in lst}

5.6.2 列表生成式

内置函数range():range函数是一个内置函数，用于生成一个整数序列。range函数有三种形式：

• range(stop) 生成一个从0开始到stop-1的整数序列，默认步长为1。
• range(start, stop) 生成一个从start开始到stop-1的整数序列，默认步长为1。
• range(start, stop, step) 生成一个从start开始到stop-1的整数序列，步长为step。

例如，range(5)将生成序列(0, 1, 2, 3, 4)，range(2, 7)将生成序列(2, 3, 4, 5, 6)，range(1, 10, 2)将生成序列(1, 3, 5, 7, 9)。

range函数一般被用在循环语句中，如for循环，来遍历一个序列或执行指定次数的循环。

5.6.3 集合生成式

集合生成式的基本语法为：

{expression for item in iterable}

expression通常是某个变量或表达式，item是可迭代对象中的元素，iterable是可迭代对象，例如列表、元组、字典等。
例如：

nums = [1, 2, 3, 4, 5]
squares = {x*x for x in nums}
print(squares)

集合表达式也支持添加条件表达式，例如：

nums = [1, 2, 3, 4, 5]
squares = {x*x for x in nums if x > 2}
print(squares)

添加条件 x>2 后，只有当x.2时，才进行迭代生成集合表达式。

5.7 切片

字符串、列表、元组等有序数据结构中支持切片操作，切片可以获取这些有序数据结构的子序列。切片操作不会改变原序列，它会返回一个新序列，包含指定范围的元素。
切片语法：

string=str[start:stop:step]

start为切片的起始位置，stop为切片的结束位置（不包括该位置对应的元素），step为切片的步长。如果省略start，则默认为0；如果省略stop，则默认为序列的长度；如果省略step，则默认为1。

6.函数——新瓶装旧酒

同C语言一样，在 Python 中，函数是一种可重用的代码块，用于执行某些特定的任务。函数可以带有参数或不带参数，也可以返回值或不返回值。C语言函数详解
函数定义的一般语法：

def add_numbers(num1, num2):
    """This function adds two numbers."""
    result = num1 + num2
    return result

• def：定义函数的关键字；
• function_name：函数名称，应以字母或下划线开头；
• parameters：函数参数，可以是一个或多个，也可以为空；
• docstring：函数文档字符串，对函数的功能进行描述，可选；
• statements：函数体，函数需要执行的代码语句。

下面用python实现一个简易的计算器，帮助大家更好的理解函数

# 加法
    def add(self, x, y):
        return x + y
    # 减法
    def subtract(self, x, y):
        return x - y
    # 乘法
    def multiply(self, x, y):
        return x * y
    # 除法
    def divide(self, x, y):
        if y == 0:
            return "除数不能为0"
        return x / y
# 获取用户输入
print("请选择运算：")
print("1、加法")
print("2、减法")
print("3、乘法")
print("4、除法")
choice = input("请输入需要进行的运算符号(1/2/3/4): ")
num1 = int(input("请输入第一个数字: "))
num2 = int(input("请输入第二个数字: "))
# 执行计算，传递两个参数 num1和num2
if choice == '1':
    print(num1,"+",num2,"=", add(num1,num2))
elif choice == '2':
    print(num1,"-",num2,"=",subtract(num1,num2))
elif choice == '3':
    print(num1,"*",num2,"=", multiply(num1,num2))
elif choice == '4':
    print(num1,"/",num2,"=",divide(num1,num2))
else:
    print("请输入正确的选项")

Python函数传参的特点如下：

位置参数：按照形参定义位置传递的参数；
关键字参数：按照形参名称传递的参数；
默认参数：在函数定义时给形参指定默认值，如果没有传入对应的实参，则使用默认值；
可变参数：*args，用来传递任意个参数，以元组的形式传递；
关键字可变参数：**kwargs，用来传递任意个关键字参数，以字典的形式传递。

 位置实参：和C语言函数传参的规则相同，实参和形参一一对应

将10传给形参a，20传给形参b
关键字实参 

形参名进行实参传
关键字实参的传参规则是，先在形参里找实参关键字，将找到的实参传递给对应形参，剩余的则进行依次传参。
可变参数
将形参定义为 *args，可接受任意个实参传递，结果为一个元组。 

关键字可变实参
将形参定义为**args，可接受任意个关键字实参，结果为一个字典。 

 函数传参的内存图
例如下面的代码

def fun(arg1,arg2):
    print("agr1=",arg1,"agr2=",arg2)
    arg1=100
    arg2.append(10)
    print("agr1=",arg1,"agr2=",arg2)
n1=10
n2=[22,33,44]
print("n1=",n1,"n2=",n2)
fun(n1,n2)
print("n1=",n1,"n2=",n2)

 运行结果：

 说明同C语言一样，C中形参是实参的一份临时拷贝，对实参的改变不影响实参。在python程序中，实参是临时定义的一个与实参指向相同的变量，改变形参的指向不能改变实参的指向，但在形参指向的首地址后面添加或删除数据是可以的起到改变实参值的作用的，因为实参也是指向这块内存的首地址，但绝对改变不了实参的指向。