【Python】基础语法（基本运算 数据结构 list 字符串 元组 字典 集合 条件语句 循环语句 except-try lambda 函数 文件 类 模块 包）

二 基础语法

1.python基本运算

1.1 标识符

Python标识符是用来标识变量、函数、类、模块等命名实体的名称。

• Python标识符的命名规则如下：
  1. 标识符只能包含字母、数字和下划线（_）。
  2. 标识符第一个字符必须是字母或下划线。
  3. 标识符不能是Python的关键字和保留字（如if、while、for等）。
  4. 标识符长度没有限制。

1.2 数据类型

• 常见数据类型

  1. 数字（Number）：整数、浮点数、复数等。

  2. 字符串（String）：由一系列字符组成的序列，可以使用单引号、双引号或三引号来表示。

  3. 布尔值（Boolean）：True和False两个值，用于表示真和假。

  4. 列表（List）：由一系列有序元素组成的可变序列，可以包含不同类型的元素。

  5. 元组（Tuple）：由一系列有序元素组成的不可变序列，可以包含不同类型的元素。

  6. 集合（Set）：由一系列不重复元素组成的无序集合。

  7. 字典（Dictionary）：由键值对组成的无序可变序列，键和值可以是不同类型的元素。

  除了以上常用的数据类型，Python还提供了其他一些内置数据类型，如字节串（bytes）、字节数组（bytearray）、枚举（enum）、空值（NoneType）等。同时，Python还支持用户自定义数据类型，如类和对象。

• 转换

  1. int(x) 将x转换为整数类型。
  2. float(x) 将x转换为浮点数类型。
  3. str(x) 将x转换为字符串类型。
  4. bool(x) 将x转换为布尔类型。
  5. list(x) 将x转换为列表类型。
  6. tuple(x) 将x转换为元组类型。
  7. set(x) 将x转换为集合类型。
  8. dict(x) 将x转换为字典类型。

1.3 运算符

• 常见运算符

  1. 算术运算符：用于数值计算，包括+ - * /、%、取整除\等。
  2. 比较运算符：用于比较两个值的大小关系，包括等于==、不等于!=、大于>、小于<、大于等于>=、小于等于<=等。
  3. 逻辑运算符：用于对布尔值进行逻辑操作，包括与and、或or、非not等。
  4. 位运算符：用于对整数在二进制下的位进行操作，包括按位与&、按位或||、按位异或^等。
  5. 赋值运算符：用于给变量赋值，包括等于=、加等+=、减等-=、乘等*=、除等/=。
  6. 成员运算符：用于判断一个值是否在另一个值中，包括in、not in。
  7. 身份运算符：用于判断两个变量是否引用同一个对象，包括is、is not。

• 优先级

  Python运算符的优先级从高到低依次是：

  1. 括号
  2. 幂运算符 **
  3. 单目加号 + 和单目减号 -
  4. 乘、除、取模运算符 *、/、%
  5. 加、减运算符 +、-
  6. 位运算符 <<、>>、&、|、^
  7. 比较运算符 ==、!=、>、<、>=、<=、in、not in、is、is not
  8. 逻辑运算符 not、and、or

2.数据结构

2.1 列表list

1）切片、索引

• 索引

  列表是一种有序的数据结构，可以存储任意类型的元素。列表中的元素可以通过索引进行访问，索引从 0 开始，表示列表中的第一个元素，依次类推。

• 切片

  list[start:end:step]
  
  倒序：
  list[::-1]
  

2）append、extend、insert

元素添加方法

• append

  在列表末尾添加一个元素，不能直接添加多个。

  list.appen(obj)
  

• extend

  在列表末尾添加另一个列表中的所有元素，即添加列表。

  list.extend(iterable)
  

• insert

  在列表的指定位置插入一个元素。

  list.insert(index,obj)
  

3）index、count

• index

  返回列表中指定元素第一次出现的索引，如果该元素不存在于列表中，则抛出 ValueError 异常。

  fruits = ['apple', 'banana', 'cherry', 'banana']
  print(fruits.index('banana'))  # 输出 1
  

• count

  返回列表中指定元素出现的次数。

  fruits = ['apple', 'banana', 'cherry', 'banana']
  print(fruits.count('banana'))  # 输出 2
  

4）len、sum、max、min

• len

  返回对象（如字符串、列表、元组等）的长度或元素个数。

• sum

  对可迭代对象中的元素进行求和操作。例如，sum([1, 2, 3]) 的结果为 6。

• max

  返回可迭代对象中的最大值。

• min

  返回可迭代对象中的最小值。

5）sort、reverse

• sort

  nums.sort() # 升序
  nums.sort(reverse=True) # 倒叙
  

• reverse

  可以对列表对象进行反转，将列表中的元素按照相反的顺序排列。

  >>> nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
  >>> nums.reverse()
  >>> print(nums)
  [5, 3, 5, 6, 2, 9, 5, 1, 4, 1, 3]
  

• lambda函数的自定义规则排序

  参数key：该参数接受一个函数，用于指定排序的规则。

  lambda函数可以方便地定义这样的规则。

  my_list = ["3345", "14", "4765", "1", "598765", "9", "28765"]
  my_list.sort(reverse=True, key=lambda x: len(x))
  print(my_list)
  >>['598765', '28765', '3345', '4765', '14', '1', '9']
  

  my_list = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
  my_list.sort(key=lambda x: len(x))
  print(my_list)
  

6）加法（合并）和乘法（重复）

• 加法

  list1 = [1, 2, 3]
  list2 = [4, 5, 6]
  combined_list = list1 + list2
  print(combined_list) # 输出 [1, 2, 3, 4, 5, 6]
  

• 乘法

  list1 = [1, 2, 3]
  repeated_list = list1 * 3
  print(repeated_list) # 输出 [1, 2, 3, 1, 2, 3, 1, 2, 3]
  

7）列表解析式

用于创建一个新列表。

• 语法：

  [expression for item in iterable if condition]
  

  expression：表达式。

  item：变量名。

  iterable：表示可迭代对象（如列表、元组、集合、字典等）。

  condition：表示一个可选的条件表达式。

• 具体来说，列表解析式的执行过程如下：

  1. 遍历iterable中的每一个元素，将其赋值给变量item；
  2. 对于满足条件condition的元素，求解表达式expression并将结果添加到新列表中；
  3. 返回新列表。

• 例：

  # 生成一个1到10的平方的列表
  squares = [x*x for x in range(1, 11)]
  print(squares) # 输出 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  
  # 生成一个1到10的偶数的列表
  evens = [x for x in range(1, 11) if x % 2 == 0]
  print(evens) # 输出 [2, 4, 6, 8, 10]
  
  # 生成一个字符串列表，其中每个字符串是原列表中对应元素的首字母
  words = ['apple', 'banana', 'cherry']
  first_letters = [word[0] for word in words]
  print(first_letters) # 输出 ['a', 'b', 'c']
  

2.2 字符串

可用单引号、双引号、三引号。

字符串是一种不可变序列。

1）合并、重复

result = "hello" * 3 + "world" * 2
print(result)  # 输出："hellohellohelloworldworld"

2）切片、索引

• 索引：从0开始，可为负数。

• 切片：

  str[start:end:step]

  倒叙：str[::-1]

3）字符串转换

• 数字转字符串：

  str(20)

• 字符串转数字：

  int(‘32’) float(‘1.2’)

  不允许 int(‘3.2’)

• 大小写字母转换

  1.upper()方法

  将字符串中所有字母变为大写。

  text = "Hello, World!"
  print(text.upper())
  # 输出结果为: HELLO, WORLD!
  

  2.lower()方法

  将字符串中所有字母变为小写。

  text = "Hello, World!"
  print(text.lower())
  # 输出结果为: hello, world!
  

  3.capitalize()方法

  将字符串首字母大写，其他字符小写。

  text = "hello, world!"
  print(text.capitalize())
  # 输出结果为: Hello, world!
  

  4.title()方法

  将字符串中每个单词的首字母都大写。

  text = "hello, world!"
  print(text.title())
  # 输出结果为: Hello, World!
  

4）字符串格式化

• 用%进行格式化

  name = "John"
  age = 30
  print("My name is %s and I'm %d years old." % (name, age))
  # 输出结果为：My name is John and I'm 30 years old.
  

  一般只要记住%s和%d就好了，这两个占位符的使用频率最高

  符号 描述

  %C 格式化字符及其ASCII码

  %s 格式化字符串

  %d 格式化整数

  %u 格式化无符号整型

  %o 格式化无符号八进制数

  %X 格式化无符号十六进制数

  %X 格式化无符号十六进制数(大写)

  %f 格式化浮点数字，可指定小数点后的精度

  %e 用科学计数法格式化浮点数

  %E 作用同%e，用科学计数法格式化浮点数

  %g %f和%e的简写

  %G %F和%E的简写

  %p 用十六进制数格式化变量的地址

• format()

  name = "John"
  age = 30
  print("My name is {} and I'm {} years old.".format(name, age))
  # 输出结果为：My name is John and I'm 30 years old.
  

• 用 f-string格式化

  name = "John"
  age = 30
  print(f"My name is {name} and I'm {age} years old.")
  # 输出结果为：My name is John and I'm 30 years old.
  

5）字符串的拆分和组合

• split()

  通过 split() 方法可以将一个字符串按照指定的分隔符进行拆分，返回一个由拆分后的子串组成的列表。

  text = "apple,banana,orange"
  fruits = text.split(",")
  print(fruits)
  # 输出结果为：['apple', 'banana', 'orange']
  

• join()

  通过 join() 方法可以将一个字符串序列（如列表或元组）中的所有元素组合成一个新的字符串并返回。

  fruits = ['apple', 'banana', 'orange']
  text = ",".join(fruits)
  print(text)
  # 输出结果为：apple,banana,orange
  

6）find、index、count、strip

• find()

  用于在字符串中查找指定子字符串第一次出现的位置，并返回其索引值。

  如果没有匹配的字符串，则返回 -1。

  str.find(sub[, start[, end]])
  
  '''
  str 表示要搜索的字符串
  sub 表示要查找的子字符串
  start 和 end 表示查找范围的起始位置和结束位置（可选参数）。
  '''
  

  • 例

    s = "hello, world"
    index = s.find("world")
    print(index)
    # 输出结果为：7
    

• index()

  index() 方法与 find() 方法类似，都是用于在字符串中查找指定子字符串第一次出现的位置，并返回其索引值。

  不同的是，如果没有匹配的字符串，则会抛出 ValueError 异常。

  str.index(sub[, start[, end]])
  
  s = "hello, world"
  try:
      index = s.index("world")
  except ValueError:
      index = -1
  print(index)
  # 输出结果为：7
  

• count()

  计算字符串中指定子字符串出现的次数，并返回计数值。

  str.count(sub[, start[, end]])
  
  s = "hello, world"
  count = s.count("o")
  print(count)
  # 输出结果为：2
  

• strip()

  strip() ：去除字符串两端的空白字符（包括空格、制表符和换行符），并返回处理后的字符串。

  lstrip()：去除左侧字符

  rstrip()：去除右侧字符。

  • 注：strip() 方法不会修改原始字符串，而是返回一个新字符串。

  str.strip([chars])
  str.lstrip([chars])
  str.rstrip([chars])
  
  
  s = "  hello, world\t\n"
  new_s = s.strip()
  print(new_s)
  # 输出结果为："hello, world"
  

2.3 元组

元组在输出时总是有括号的。

元组在输入时可以没有。

像字符串一样，元组是不可变的。

索引、切片以及一些方法很多与列表相似。

1）定义

元组是一种不可变序列，它与列表类似，但元组的元素不能修改。元组中的元素可以是任意类型的，包括数字、字符串、列表和其他元组等。

2）创建元组

用小括号括起来。

t1 = (1, 2, 3)
t2 = ('apple', 'banana', 'orange')
t3 = (1, 'hello', [1, 2, 3])

3）访问元组

可通过索引值访问，索引值从0开始计数。

t = (1, 2, 3, 4, 5)
print(t[0])  # 输出结果为：1
print(t[3])  # 输出结果为：4

4）元组切片

t[start:end:step]

t = (1, 2, 3, 4, 5)
print(t[1:3])   # 输出结果为：(2, 3)
print(t[::2])   # 输出结果为：(1, 3, 5)

5）元组拼接

可以使用加号操作符将两个元组拼接成一个新元组。

t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2
print(t3)   # 输出结果为：(1, 2, 3, 4)

6）元组解包

可以使用解包操作符 * 将元组中的元素解包成单独的变量。

t = (1, 2, 3)
a, b, c = t
print(a, b, c)  # 输出结果为：1 2 3

7）元组方法

• count(): 返回指定元素在元组中出现的次数。
• index(): 返回指定元素在元组中第一次出现的位置。

8）不可变性

元组是不可变序列，这意味着一旦创建了元组，就不能修改其中的元素。

如果需要修改元素，则需要先将元组转换为列表，修改后再转换回元组。

# 将元组转换为列表
t = (1, 2, 3)
lst = list(t)

# 修改列表中的元素
lst[1] = 4

# 将列表转换回元组
new_t = tuple(lst)

print(new_t)   # 输出结果为：(1, 4, 3)

9）元组和列表的转换

2.4 字典

键(key)与值(value)

关键字(键值) 必须是不可变类型，

如不能用列表作为关键字；元组和字符串不可变，能作为关键字。

关键字必须互不相同（唯一）。

值可以为任何数据类型，包括数字、字符串、列表和其他字典等。

1）创建字典

可以使用大括号和逗号分隔符来创建字典，并用冒号将键和值分隔开。

d1 = {'name': 'John', 'age': 30, 'city': 'New York'}
d2 = {1: 'apple', 2: 'banana', 3: 'orange'}
d3 = {'name': 'Mary', 'pets': ['dog', 'cat']}

2）访问元素

可以通过指定键来访问字典中的元素。

如果指定的键不存在，则会抛出 KeyError 异常。

d = {'name': 'John', 'age': 30, 'city': 'New York'}
print(d['name'])   # 输出结果为：John
print(d['age'])    # 输出结果为：30

3）修改元素

可以通过指定键来修改字典中的元素。

d = {'name': 'John', 'age': 30, 'city': 'New York'}
d['age'] = 31
print(d)   # 输出结果为：{'name': 'John', 'age': 31, 'city': 'New York'}

4）添加元素

可以通过指定新的键和值来向字典中添加元素。

d = {'name': 'John', 'age': 30, 'city': 'New York'}
d['country'] = 'USA'
print(d)   # 输出结果为：{'name': 'John', 'age': 30, 'city': 'New York', 'country': 'USA'}

5）删除元素

可以使用 del 关键字来删除字典中的元素。

d = {'name': 'John', 'age': 30, 'city': 'New York'}
del d['age']
print(d)   # 输出结果为：{'name': 'John', 'city': 'New York'}

6）字典方法

• keys(): 返回字典中所有键组成的列表。
• values(): 返回字典中所有值组成的列表。
• items(): 返回字典中所有键值对组成的列表。
• get(): 返回指定键的值，如果不存在，则返回默认值（可选参数）。
• pop(): 弹出指定键的值，并将其从字典中删除。
• update(): 将一个字典的键值对更新到另一个字典中。

# 创建一个字典
d = {'name': 'John', 'age': 30, 'city': 'New York'}

# keys() 方法
print(d.keys())   
# 输出结果为 dict_keys(['name', 'age', 'city'])

# values() 方法
print(d.values())  
# 输出结果为 dict_values(['John', 30, 'New York'])

# items() 方法
print(d.items())   
# 输出结果为 dict_items([('name', 'John'), ('age', 30), ('city', 'New York')])

# get() 方法
print(d.get('name'))   
# 输出结果为 John
print(d.get('gender', 'unknown'))   
# 输出结果为 unknown（默认值）

# pop() 方法
print(d.pop('age'))   
# 输出结果为 30
print(d)   
# 输出结果为 {'name': 'John', 'city': 'New York'}

# update() 方法
d2 = {'country': 'USA', 'age': 31}
d.update(d2)
print(d)   
# 输出结果为 {'name': 'John', 'city': 'New York', 'country': 'USA', 'age': 31}

7）不可哈希性

字典中的键必须是不可变类型，如数字、字符串、元组等。

这是因为字典使用哈希表来实现，需要将键的哈希值作为索引值来访问数据。

如果键是可变类型，则在修改键的值时可能会导致哈希值发生变化，从而破坏字典的内部结构。

2.5 集合

集合是一种无序、可变的数据类型，用于存储一组唯一的元素。集合中的元素必须是不可变的，例如数字、字符串、元组等。

1）创建集合

可以使用大括号和逗号分隔符来创建集合。

s1 = {1, 2, 3, 4, 5}
s2 = {'apple', 'banana', 'orange'}
s3 = set('hello')

2）访问元素

由于集合是无序的，因此不能直接通过下标来访问元素。

可以使用循环或 in 关键字来判断某个元素是否在集合中。

s = {1, 2, 3, 4, 5}
for x in s:
    print(x)
    
print(2 in s)   # 输出结果为 True

3）修改元素

由于集合是可变的，因此可以添加、删除元素来修改集合。

注意，如果尝试删除一个不存在的元素，会抛出 KeyError 异常。

可以使用 discard() 方法来删除元素，它会忽略不存在的元素而不会抛出异常

s = {1, 2, 3}
s.add(4)    # 添加元素
s.remove(2)    # 删除元素
print(s)   # 输出结果为 {1, 3, 4}

4）集合运算

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1 | s2)    # 并集，输出结果为 {1, 2, 3, 4}
print(s1 & s2)    # 交集，输出结果为 {2, 3}
print(s1 - s2)    # 差集，输出结果为 {1}
print(s1 ^ s2)    # 对称差，输出结果为 {1, 4}

5）集合方法

• add(): 向集合中添加一个元素。
• remove(): 删除集合中的指定元素。
• pop(): 随机弹出集合中的一个元素，并将其从集合中删除。
• clear(): 清空集合中的所有元素。
• union(): 返回两个集合的并集。
• intersection(): 返回两个集合的交集。
• difference(): 返回两个集合的差集。
• symmetric_difference(): 返回两个集合的对称差

# 创建两个集合
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}

# add() 方法
s1.add(6)
print(s1)   # 输出结果为 {1, 2, 3, 4, 5, 6}

# remove() 方法
s1.remove(1)
print(s1)   # 输出结果为 {2, 3, 4, 5, 6}

# pop() 方法
x = s1.pop()
print(x)   # 输出结果为 2
print(s1)   # 输出结果为 {3, 4, 5, 6}

# clear() 方法
s1.clear()
print(s1)   # 输出结果为 set()

# union() 方法
s3 = s1.union(s2)
print(s3)   # 输出结果为 {4, 5, 6, 7, 8}

# intersection() 方法
s4 = s1.intersection(s2)
print(s4)   # 输出结果为 set()

# difference() 方法
s5 = s1.difference(s2)
print(s5)   # 输出结果为 set()

# symmetric_difference() 方法
s6 = s1.symmetric_difference(s2)
print(s6)   # 输出结果为 {4, 5, 6, 7, 8}

3.控制结构

3.1 条件语句

if 、if …else…、if …elif …else

三元表达式： A = Y if X else Z

x = 10

# 单个 if 语句
if x > 5:
    print("x 大于 5")

# if-else 语句
if x > 15:
    print("x 大于 15")
else:
    print("x 小于等于 15")

# if-elif-else 语句
if x > 20:
    print("x 大于 20")
elif x > 15:
    print("x 大于 15，小于等于 20")
else:
    print("x 小于等于 15")

# and 运算符
if x > 5 and x < 15:
    print("x 大于 5 且小于 15")

# or 运算符
if x < 5 or x > 15:
    print("x 小于 5 或大于 15")

# not 运算符
if not x > 15:
    print("x 不大于 15")

# 嵌套的 if 语句
if x > 5:
    if x < 15:
        print("x 大于 5 且小于 15")
    else:
        print("x 大于等于 15")
else:
    print("x 小于等于 5")
    
    
# 使用 if 的三元表达式
# 表达式1 if 条件 else 表达式2
y = "x 大于 5" if x > 5 else "x 小于等于 5"
print(y)   # 输出结果为 "x 大于 5"

3.2 循环语句

1）while

count = 0

# while 循环，打印数字 0~9
while count < 10:
    print(count)
    count += 1

# while-else 语句
count = 5
while count < 10:
    print(count)
    count += 1
else:
    print("count 大于等于 10")

# break 和 continue 语句
count = 0
while count < 10:
    if count == 5:
        count += 1
        continue
    elif count == 8:
        break
    else:
        print(count)
        count += 1

# 死循环
# while True:
#     print("Hello, world!")

2）for

1. range() 函数：

   生成数字序列。

   range() 函数有三个参数：起始值、终止值和步长，默认起始值是 0，步长是 1。

   例如，range(2, 10, 2) 将会生成从 2 开始，每次增加 2，直到小于 10 的数字序列。

2. enumerate() 函数：

   同时返回每个元素的索引和对应的值。

   例如，for i, element in enumerate([‘a’, ‘b’, ‘c’]): 将会依次输出 (0, ‘a’)、(1, ‘b’)、(2, ‘c’)。

3. zip() 函数：

   将多个序列“压缩”成一个序列。

   例如，for x, y in zip([‘a’, ‘b’, ‘c’], [1, 2, 3]): 将会依次输出 (‘a’, 1)、(‘b’, 2)、(‘c’, 3)。

# range() 函数的使用
for i in range(5):
    print(i)

# enumerate() 函数的使用
fruits = ['apple', 'banana', 'cherry']
for i, fruit in enumerate(fruits):
    print("The index of", fruit, "is", i)

# zip() 函数的使用
# 将每个序列中具有相同索引位置的元素打包成一个元组
fruits = ['apple', 'banana', 'cherry']
prices = [1.5, 2.0]
# 将 zip() 返回的迭代器转换为列表
result = list(zip(fruits, prices))
print(result) # [('apple', 1.5), ('banana', 2.0)]

cars = ['Audi', 'BMW', 'Tesla']
prices = [50000, 60000, 80000]
for car, price in zip(cars, prices):
    print(car, "costs", price)

3）break、continue、pass

• break

  用于跳出循环。

  当程序执行到 break 时，循环将会被立即终止，然后程序会开始执行循环之后的语句。

• continue

  跳过当前循环的剩余语句，立即开始下一轮循环。

  当程序执行到 continue 时，循环体中 continue 之后的语句将会被忽略，直接开始下一轮循环。

• pass

  pass 语句仅仅是一个占位符，不做任何操作。

  通常用于占据一个代码块的位置，以便在程序设计时进行功能扩展。

3.3 except-try 语句

except-try 语句用于捕捉并处理异常。

当程序出现异常时，可以使用 try-except 语句进行处理，以保证程序不会崩溃。

try:
    # 可能引发异常的语句块
except 异常类型1:
    # 异常处理语句块1
except 异常类型2:
    # 异常处理语句块2
...
else:
    # 正常执行语句块
finally:
    # 无论是否发生异常都会执行语句块

• 例：

  try:
      x = int(input("请输入一个数字: "))
      y = 10 / x
  except ZeroDivisionError:
      print("除数不能为0")
  except ValueError:
      print("输入错误，请输入数字")
  else:
      print("计算结果:", y)
  finally:
      print("程序结束")
  

• except 语句可以省略异常类型，这样就能捕获任何异常：

  try:
      # 可能引发异常的语句块
  except:
      # 异常处理语句块
  

3.4 列表解析与生成器表达式

列表解析与生成器表达式:

区别

[x for x in range(10) if x%2==0]

(x for x in range(10) if x%2==0)

列表解析（List Comprehension）和生成器表达式（Generator Expression）都是用来快速创建一个列表或生成器的语法

1）列表解析

创建列表的方式。

• 语法

  [expression for item in iterable if condition]
  
  expression 是要对每个可迭代元素进行计算的表达式。
  item 是可迭代对象中的元素。
  iterable 是可迭代对象。
  condition 是条件语句（可以省略）。
  

• 例

  squares = [x**2 for x in range(10)]
  

2）生成器表达式

生成器表达式和列表解析非常类似，

不同之处在于它们返回的是一个生成器对象，而不是一个列表。

生成器表达式的语法和列表解析一样，只需要使用圆括号()代替方括号[]即可。

(x**2 for x in range(10) if x%2==0)

4.函数

4.1 函数参数的几种形式

1.f(x1,x2,…)。

2.f(x1,x2=value,…)：

提供默认值注。

3.f(*x):

加表示参数个数不确定，可以0个或n个，不管多少个，参数值都存放在名为x的元组中。

4.f(**x):

加**也表示参数个数不确定，参数值存放在名为x的字典中。

以上多种参数定义方式的混合

# 位置参数
def add(a, b):
    return a + b

result = add(10, 20)
print(result) # 输出：30


# 关键字参数
def print_info(name, age, gender):
    print("姓名：", name)
    print("年龄：", age)
    print("性别：", gender)

print_info(age=25, name="Mike", gender="男")
# 输出：
# 姓名： Mike
# 年龄： 25
# 性别： 男


# 默认参数
def print_greeting(name="World"):
    print("Hello, ", name)

print_greeting()         # 输出：Hello, World
print_greeting("Mike")   # 输出：Hello, Mike


# 可变长参数
def print_numbers(*numbers):
    for num in numbers:
        print(num)

print_numbers(1, 2, 3, 4, 5)
# 输出：
# 1
# 2
# 3
# 4
# 5

4.2 lambda函数

lambda是一个表达式，而def是一个语句。

lambda函数是一种匿名函数，用于创建简单的可调用对象。

lambda函数可以作为参数传递给其他函数，也可以作为返回值返回。

1）定义

lambda arguments: expression

arguments 是参数列表，可以是0个或多个，用逗号分隔。
expression 是一个表达式，通常是简单的一行代码，它会被返回。

例:

add = lambda a, b: a + b
result = add(10, 20) # 返回：30

2）排序

多维数据，排序以谁为准？

对多维数组排序时需要指定按照哪个元素进行排序。

students = [
    {"name": "Tom", "age": 18},
    {"name": "Mike", "age": 22},
    {"name": "Jane", "age": 20}
]

sorted_students = sorted(students, key=lambda student: student["age"])

3）map()

对一个可迭代对象中的每个元素都应用一个指定的函数。

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

squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出：[1, 4, 9, 16, 25]

# lambda函数的作用是将输入的参数平方，并返回结果。
# map()函数则会对numbers列表中的每个元素都应用这个lambda函数，
# 然后将结果存储在squared列表中。

4）reduce()

对一个序列累积计算。

from functools import reduce

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

product = reduce(lambda a, b: a * b, numbers)
print(product) # 输出：120

# lambda函数的作用是将输入的两个参数相乘，并返回结果。
# reduce()函数则会对numbers列表中的所有元素依次应用这个lambda函数，从而计算出所有元素的乘积。

5）filter()

用于过滤序列中的元素，只保留符合条件的元素。

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

evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # 输出：[2, 4]

# lambda函数的作用是判断输入的参数是否是偶数，并返回一个布尔值。
# filter()函数则会对numbers列表中的每个元素都应用这个lambda函数，筛选出所有符合条件的偶数元素，
# 并将结果存储在evens列表中。

4.3 内置函数

from functools import reduce

# map()函数
# 对一个序列中的每个元素都应用一个指定的函数，然后将结果存储在另一个序列中。
numbers = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x+1, numbers))
print(new_list) # 输出：[2, 3, 4, 5, 6]

# filter()函数
# 过滤序列中的元素，只保留符合条件的元素。
numbers = [1, 2, 3, 4, 5]
new_list = list(filter(lambda x: x>3, numbers))
print(new_list) # 输出：[4, 5]

# reduce()函数
# 对一个序列进行累积计算。
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x*y, numbers)
print(product) # 输出：120

# len()函数
# 返回一个序列、元组或字典的长度。
text = "Hello, world!"
length = len(text)
print(length) # 输出：13

# sum()函数
# 对一个序列中所有元素进行求和。
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total) # 输出：15

# max()和min()函数
numbers = [1, 2, 3, 4, 5]
maximum = max(numbers)
minimum = min(numbers)
print(maximum) # 输出：5
print(minimum) # 输出：1

5.模块、包

模块和包是组织代码的基本单元之一。

• 模块

  模块是一个包含Python代码的文件。模块可以包含函数、类、变量等。

  • 导入模块的方式

    # 直接导入模块
    import math
    print(math.sqrt(4))
    
    # 导入模块中的部分内容
    from time import time, sleep
    start = time()
    sleep(2)
    end = time()
    print('Time elapsed:', end - start)
    
    # 为导入的内容指定别名
    from urllib.request import urlopen as uopen
    response = uopen('https://www.baidu.com')
    html = response.read()
    print(html)
    
    # 导入模块中的所有内容（不推荐）
    # 因为它可能会导致命名空间冲突，使代码更难以理解和维护。
    from random import *
    print(randint(1, 100))
    

• 包

  包是一种将模块组织在一起的方式。

  包是一个包含多个模块的文件夹，通常还包括一个名为__init__.py的特殊文件。

6.文件操作

• 文件编码

编码是一种规则集合，记录内容和二进制间相互转换的逻辑。

最常用：UTF-8编码

6.1 读取操作

## 打开文件获取文件对象
# mode:读取模式（r：只读；w:删除原内容，若不存在则创建；a：追加内容，若不存在则创建）
# encoding：编码格式（一般UTF-8）
文件对象=open(file,mode,encoding)

## 读取指定长度字节
# 不指定则读全部
文件对象.read(num)

## 读取一行
文件对象.readline()

## 读取全部行，得到列表
文件对象.readlines()

## 循环文件行，一次循环得一行
for line in 文件对象

## 关闭文件对象
文件对象.close()

## 打开用完后，自动关闭
with open('文件名',) as f:
     data=file.read()

• 注：读取完后一定要close，不然文件会一直被占用。

6.2 写操作

f=open('1.txt','w') # 创建新文件，只允许写
f=open('filename','a') # 在已经存在的文件中追加内容

# 文件写入
f.write('zyy') # 并没有写入文件，而是在缓冲区，当flush或者close时写入文件
#（为了避免频繁打开硬盘浪费时间）
# 内容刷新
f.flush() # 内容写入硬盘

# 将一个字符串列表（或可迭代对象）写入到文件中。
f.writelines(list)
# 如：
file = open('example.txt', 'w')
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file.writelines(lines) # 写入字符串列表到文件中
file.close() # 关闭文件

7.类

7.1 对象

• Python从设计之初就是面向对象的一门语言。

• 概念：

对象是类的实例化结果，是类的具体表现形式。

一个类可以创建多个不同的对象，每个对象都具有相同的属性和方法，但是它们的数据可能不同。

例如，一个Person类可以创建多个不同的Person对象，每个对象都有姓名、年龄等属性，但是这些属性的值可能不同。

7.2 类

类是一种数据结构，它封装了一组数据和方法。

1）定义

# ClassName是类的名称；attribute是类的数据属性；method是类的方法属性。在方法中，第一个参数self指代实例对象本身
class ClassName:
    attribute1 = value1
    attribute2 = value2

    def method1(self, arg1, arg2):
        pass

    def method2(self, arg1, arg2):
        pass

2）数据属性

数据属性是类中存储的数据，它们是类的一个组成部分。

在Python中，我们可以通过在类中定义变量来定义数据属性。

例如，下面是一个简单的Person类，其中包含了两个数据属性name和age：

class Person:
    name = ''
    age = 0

3）方法属性

方法属性是类中用于处理数据的函数，它们也是类的一个组成部分。

在Python中，我们可以通过在类中定义函数来定义方法属性。

例如，下面的Person类中包含了两个方法属性introduce和grow_up：

class Person:
    name = ''
    age = 0

    def introduce(self):
        print('My name is', self.name, 'and I am', self.age, 'years old.')

    def grow_up(self, years):
        self.age += years

4）类的实例化

obj = ClassName()

• 例：实例化及调用

class Person:
    name = ''
    age = 0

    def introduce(self):
        print('My name is', self.name, 'and I am', self.age, 'years old.')

    def grow_up(self, years):
        self.age += years

# 创建一个Person对象
p1 = Person()

# 访问对象的属性并赋值
p1.name = 'Tom'
p1.age = 20

# 调用对象的方法
p1.introduce()

# 年龄增加2岁
p1.grow_up(2)

# 再次调用对象的方法
p1.introduce()

5）类的继承

创建一个新的类，该类从另一个现有的类中继承了数据属性和方法属性。

class ChildClass(ParentClass):
    # 子类的代码

• 例：

  class Person:
      name = ''
      age = 0
  
      def introduce(self):
          print('My name is', self.name, 'and I am', self.age, 'years old.')
  
      def grow_up(self, years):
          self.age += years
  
  class Student(Person):
      grade = 0
  
      def learn(self, subject):
          print(f'I am studying {subject} in grade {self.grade}.')
  
  # 创建一个Student对象
  s1 = Student()
  
  # 访问和赋值对象的属性
  s1.name = 'Tom'
  s1.age = 20
  s1.grade = 10
  
  # 调用对象的方法
  s1.introduce()
  s1.learn('math')
  

性是类中用于处理数据的函数，它们也是类的一个组成部分。

在Python中，我们可以通过在类中定义函数来定义方法属性。

例如，下面的Person类中包含了两个方法属性introduce和grow_up：

class Person:
    name = ''
    age = 0

    def introduce(self):
        print('My name is', self.name, 'and I am', self.age, 'years old.')

    def grow_up(self, years):
        self.age += years

4）类的实例化

obj = ClassName()

• 例：实例化及调用

class Person:
    name = ''
    age = 0

    def introduce(self):
        print('My name is', self.name, 'and I am', self.age, 'years old.')

    def grow_up(self, years):
        self.age += years

# 创建一个Person对象
p1 = Person()

# 访问对象的属性并赋值
p1.name = 'Tom'
p1.age = 20

# 调用对象的方法
p1.introduce()

# 年龄增加2岁
p1.grow_up(2)

# 再次调用对象的方法
p1.introduce()

5）类的继承

创建一个新的类，该类从另一个现有的类中继承了数据属性和方法属性。

class ChildClass(ParentClass):
    # 子类的代码

• 例：

  class Person:
      name = ''
      age = 0
  
      def introduce(self):
          print('My name is', self.name, 'and I am', self.age, 'years old.')
  
      def grow_up(self, years):
          self.age += years
  
  class Student(Person):
      grade = 0
  
      def learn(self, subject):
          print(f'I am studying {subject} in grade {self.grade}.')
  
  # 创建一个Student对象
  s1 = Student()
  
  # 访问和赋值对象的属性
  s1.name = 'Tom'
  s1.age = 20
  s1.grade = 10
  
  # 调用对象的方法
  s1.introduce()
  s1.learn('math')