[学习笔记 Day01]Python基础：从众学习，便捷你我，提高开发效率，探索编程语言

前言：

Python自1991年发布以来，历时30多年，逐步受到大家的喜爱，目前Python超越了Java、C、C++、Javascript等，成为最受欢迎的编程语言。

Python编码规范：

注释：

• 单行注释：#
• 多行注释：使用三个单引号或是三个双引号
• 中文注释：

  #coding = utf-8
  #或者
  #coding = gbk

标识符命名规范：

1. 标识符是由字符（A~Z和a~z）、下划线和数字组成，但是第一个标识符不能是数字。
2. 标识符不能包含空格、@、%以及$等特殊字符。
3. 标识符区分大小写，如age和Age是不同的标识符。
4. 标识符不能使用Python中的保留字。

and	as	assert	break	class
def	del	elif	else	except
or	from	False	global	if
in	is	lambda	nomlocal	not
continue	pass	raise	return	try
while	finally	import	None	True
yield	with

文件扩展名

• .py文件：Python 源代码的标准文件扩展名。
• .pyc文件：Python 编译过的字节码文件。
• .pyw文件：通常用于图形用户界面的应用程序。
• .pyd文件：Python 的动态链接库。

语法基础

变量与常量

• 变量：不需要事先声明变量名及其类型。
• 常量：其名称全部使用大写字母。

扩展：

• type(变量名)：返回变量的数据类型。

x = 5
print(type(x))
//输出：<class 'int'>

• isinstance(变量名,数据类型)：用于判断变量是否为某个数据类型

y = "Python"
print(isinstance(y,int))
//输出：False

Python 的内存管理机制

1. Python 的内存管理机制主要是通过自动内存管理和垃圾回收来实现的，从而使开发者能够更加专注于程序逻辑的编写，而无须过多的关注内存管理问题。
2. 在 Python 中可以通过运算符“==”、“is”或者 id() 函数来判断是否引用的是同一个内存地址的变量。

x = 9
print(id(9))
//输出：1906008480

数据类型：

主要的数据类型：Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）等。

数据类型	说明
int	整数
float	浮点数
bool	布尔值
str	字符串
list	列表
tuple	元组
dict	字典
set	集合

运算符与表达式

运算符主要包括：算术运算符、赋值运算符、比较运算符、逻辑运算符、身份运算符、成员运算符和位运算符。

算术运算符

运算符	说明
+	加：两个对象相加
–	减：得到负数或一个数减去另外一个数
*	乘：两个数相乘或是返回一个被重复若干次的字符串
/	除：x 除以 y
%	取余：返回除法的余数
**	幂：返回 x 的 y 次幂
//	取整数：返回商的整数部分（向下取整）

赋值运算符

赋值运算符只有一个，即“=”。

比较运算符

运算符	说明
==	检查两个操作数的值是否相当
!=	检查两个操作数的值是否不相等
>	检查左操作数的值是否大于右操作数的值
<	检查左操作数的值是否小于右操作数的值
>=	检查左操作数的值是否大于或等于右操作数的值
<=	检查左操作数的值是否大于或等于右操作数的值

逻辑运算符

运算符	逻辑表达式	描述
and	x and y	布尔“与”，如果 x 为 False ，x and y 返回 False，否则返回y的计算值
or	x or y	布尔“或”，如果 x 为 True，x and y 返回 True，否则返回y的计算值
not	not x	布尔“或”，如果 x 为 True，x and y 返回 True，如果 x 为 False，x and y 返回 False

成员运算符

运算符	描述
in	如果在指定的序列中找到值，返回 True ，否则返回 False
not in	如果在指定的序列中找到值，返回 False ，否则返回 True

身份运算符

运算符	描述
is	判断六个数据引用的对象是否一致
not is	判断六个数据引用的对象是否不一致

位运算符

运算符	含义说明	实例
&	按位与	如果两位均为1，则将每个位设为1
|	按位或	如果两位中的一位为1，则将每个位设为1
^	按位异或	如果两个位中只有一位为1，则将每个位设为1
~	按位取反	反转所有位
<<	按位左移	通过从右侧推入零来向左移动，推掉最左边的位
>>	按位右移	通过从左侧推入零来向右移动，推掉最右边的位

运算符	含义说明
**	幂
+、-	正号和负号
*、/、//、%	算术运算符
*、-	算术运算符
<<、>>	位运算符中的左移和右移
&	位运算符中的位与
^	位运算符中的位异或
|	位运算符中的位或
>、>=、<、<=、=、!=	比较运算符

基本输入与输出

input()函数

• Python 中的内置函数，用于从用户那里获取输入，以字符串的形式返回
• 语法格式：

input(prompt='',default='')
//prompt:显示用户输入之前的提示文本
//default:输入提示中的默认值，用户可以直接按 Enter 键来选择这个默认值

print()函数

• 在Python中，print() 函数的作用是在屏幕上显示信息，经常用于输出变量、文本和其他内容。
• 语法格式：

print(*objects,sep = '',end = '',file = sys.stdout,flush = False)

//*objects：通过逗号分隔传递给 print() 函数的多个对象。
//sep：指定分隔符，默认为 sep=''（空格）
//end：指定结尾标志，默认为 end='\n'

• 字符串的格式化输出：
  • %形式：print("xxxxx %s xxxxx %s " % (value1,value2))
    • %s：是格式化符，表示把后面的值格式化为字符类型。类似的格式化符还有%d、%f等。
    • %d：格式化数字
    • %.1f：保留一位小数
  • f 形式：print(f"内容{表达式}")
  • format形式：print("xxxxx {} xxxxx {}".format(value1,vlaue2))
    • 可以使用{}来指定变量的位置，如："xxxxx { 1 } xxxxx { 0 }".format(value1,vlaue2)
    • 可以使用关键字来指定变量出现的位置，如："xxxxx { val2 } xxxxx { val1 }".format(val1 = value1,val2 = vlaue2)
    • 另外可以使用字典当关键字参数传入值，在字典前面加 ** 即可。如："xxxxx { key1 } xxxxx { key2 }".format( ** dict )
    • 通过下标方式访问，如："xxxxx { 0[0] } xxxxx { 0[1] }".format(arr),0[1]表示在format列表中的第0位索引位置的arr数组。
    • 填充与格式化：format不仅可以输出字符串，还可以设置输出的字符串的填充以及对齐方式。如："xxxxx {:填充字符 对齐方式'<>'[字符宽度]}".format()
      • “:”后面为指定的填充字符，只能是一个字符，默认为空格。
      • 对齐方式有^、<、>：分别为居中、左对齐和右对齐。
    • 精度与进制：{:符号}.format()
      • 相关符号：

符号	含义
b	自动转换成二进制表示，然后格式化
c	自动转换成对应的 Unicode 字符
d	十进制数
o	自动转换为八进制表示，然后格式化
x	自动转换为十六进制，然后格式化（小写 x）
X	自动转换为十六进制，然后格式化（大写 X）
,	将数据进行千分位格式化

例如：

print('{0:b},{1:o},{2:x}'.format(12,12,12));  //1100,14,c
print('{0:.2f}'.format(1/3));                 //0.33
print('{0:,}'.format(102345475956));          //102,345,475,956

内置函数

数据类型相关的内置函数：

函数	描述	函数	描述
bool()	将参数转换为布尔类型	tuple()	将序列转换为元组类型
int()	将参数转换为整型	dict()	将序列转换为字典类型
str()	将参数转换为字符串类型	list()	将序列转换为列表类型
float()	将参数转换为浮点类型	set()	将序列转换为集合类型
bytes()	将参数转换为字节型数组	zip()	将参数转换为可迭代对象集合
bytearray()	将参数转换为字节数组

进制转换相关的函数：

函数	描述	函数	描述
bin()	将参数转换为二进制	hex()	将参数转换为十六进制
oct()	将参数转换为八进制

数学运算相关函数：

函数	描述	函数	描述
abs()	返回绝对值	sum()	求和
divmode()	返回商和余数	min()	求最小值
round()	四舍五入	max()	求最大值
pow(a,b)	求 a 的 b 次幂

其他函数：

函数	描述	函数	描述
map(funcion,iterable)	对一个可迭代对象（如：列表、元组等）中的每个元素执行一个指定的函数，并将结果收集成一个新迭代器	eval(str)	执行一个字符串类型的表达式，并返回表达式的结果

例如：

y = list(map(int,['12','34',''56]));
print(y);//[12,34,56]

print(eval('1 + 5 + 8'))；//14

程序控制语句

• 单分支结构：if 条件表达式: 方法块;
• 双分支结构：if 条件表达式: 方法块; else: 方法块;
  • 三元运算符：当条件表达式为 True 时，返回表达式1，否则反之。
    • 语法：表达式1 if 条件表达式 else 表达式2
• 多分支结构：if 条件表达式: 方法块; elif 条件表达式: 方法块; else: 方法块;
• 循环结构：
  • for 循环：for 变量 in 序列: 循环语句;
    • range(start,stop[,step])：用于生成一个整数序列
      • start：表示序列的起始值（包含），默认为0
      • stop：表示序列的结束值（不包含）
      • step：表示序列中相邻两个数之间的差（步长），默认为1
  • while 循环：while 条件表达式: 循环语句;
• break语句：用于跳出循环
• continue语句：用于跳出本次循环，进入下一次循环

序列

在计算机科学和编程领域，数据结构是组织和存储数据的方式，他对数据数据的处理效率和程序的性能有着重要的影响。

列表

特点：

• 列表中的元素是有序的，其元素是按照插入的顺序进行排列的，可以通过索引访问每个元素。
• 列表是可变的（添加、修改、删除）
• 列表可以动态的增长和缩短。

语法：

• 定义列表：my_list = [1, 2, 3, 4, 5, 6, 7, "aaa"]
  • 定义一个空列表：list = []
  • 使用 list 函数定义列表：list = list((1, 2, 3))
    • 将字符串转换成列表：list = list("hello")
• 添加元素：
  • 在列表末尾添加：my_list.append(4)
  • 在指定位置添加：my_list.insert(索引位置, 要添加的内容)
  • 在列表末尾添加一个列表：my_list.extend([1, 2, 3])
  • 使用 += 来添加列表到列表末尾：my_list += [1, 2, 3]
• 修改列表元素：
  • 通过索引修改：list[0] = "a"
• 删除列表元素：
  • 使用 pop 函数来删除元素：list.pop(索引位置)
  • 使用 del 语句来删除元素：del list[索引位置]
  • 使用 remove 函数类删除元素：list.remove(索引位置)
• 查找列表元素：
  • for 循环列表：
    • for item in my_list: 循环体
    • for item not in my_list: 循环体
  • 访问元素：print(my_list[0])
  • 使用 index 函数：list.index(索引位置)
• 排序与逆置：
  • 使用 sort 函数（不会返回一个新的列表）：list.sort()
  • 使用 sorted 函数（会返回一个新的列表）：new_list = sorted(list)
    • sorted(iterable, cmp = None, Key = None, reverse = False)
      • iterable：表示可迭代对象
      • cmp：是一个函数，用于从每个项目中提取一个用于比较的值
      • key：用来进行比较的值
      • reverse：排序规则（降序：True；升序：Fasle）
• 切片：list[start : end : step]
  • list[2 : 5]：提取从索引2到5的值（不包括索引为5的值）
  • list[2 : 6 : 2]：提取从索引2到6的值，每隔1个元素取一个值（步长为2）
  • list[8 : 2 : -2]：提取从索引2到8的值，每隔1个元素取一个值（步长为-2）
  • list[2 : ]：提取从索引2到末尾的值
• 内置函数：
  • 获取列表的长度：len(my_list)
  • 获取序列中的最大值 / 最小值：max(list) / min(list)
  • 获取序列中所有元素的和：sum(list)
  • 将两个可迭代对象一一对应打包成一个个元组：zip(list1 , list2)
  • 将可遍历的数据对象组合成一个索引序列：for key, value in enumerable(list):循环体
  • 获取到列表的迭代器对象：iter(列表变量)

list = ['apple' , 'banana' , 'cherry']

for key , value in enumerable(list):
      print(key , value)

# 0 apple
# 1 banana
# 2 cherry

• 列表推导式：[expression for item in list if condition]

[ x for x in range(1 , 11) if x % 2 == 0]

# 2,4,6,8,10

元组

定义：元组是一个有序的、不可改变的元素的集合，其元素可以是任何数据类型

元组与列表的差异：

列表	元组
可变的（修改、添加和删除元素）	不可变的（一旦创建就不可以修改）
常用于可能会改变的数据集合	常用于不会改变的数据集合
操作通常比元组慢	在某些情况下（尤其是大量数据处理时）会更快
使用 [] 定义	使用 () 定义
提供了更多的内置方法，如：append()、remove()、reverse()等	只有哪些不能改变其内容的内置方法，如count()、index()等
常用于存储和操作数据	常用于读取数据，尤其是数据的顺序很重要且不能改变的时候
不能用作字典的键	可以用作字典的键

注意：他们都支持通过索引和切片来访问数据，但由于元组的不可改变，所以使用索引或切片修改元组实际上是创建了一个新的元组。

语法：

• 创建元组：tuple = (1 , "apple" , 2 , 3)
  • 创建空元组：tuple = ()
  • 调用 tuple() 函数创建元组：my_tuple = tuple([1 , 2 , 3])
    • 将字符串转换成元组：my_tuple = tuple("apple")
• 访问元组元素：print(tuple[0])
  • 使用 for 循环遍历：for item in tuple: print(item)
• 删除元组：del tuple
• 元组切片：
  • 提取从索引2到5的元素（不包括索引位置5的元素）：tuple[2 : 5]
  • 提取从索引2到6的值，每隔1个元素取一个值（步长为2）：tuple[2 : 6 : 2]
  • 提取从索引2到8的值，每隔1个元素取一个值（步长为-2）：tuple[8 : 2 : -2]
  • 提取从索引2到末尾的值：tuple[2 : ]
• 元组推导式：（与列表推导式相同）

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

# Result is [(0 , 0),(1 , 1),(2 , 4),(3 , 9),(4 , 16),(5 , 25),(6 , 36),(7 , 49),(8 , 64),(9 , 81)]

序列解包：

多个变量同时赋值：

x,y,z = 1,5,9

print(x)
# result => 1
print(y)
# result => 5
print(z)
# result => 9

对 range 对象进行序列解包：

x,y,z = range(3)

print(x)
# result => 0
print(y)
# result => 1
print(z)
# result => 2

使用迭代器对对象进行解包：

my_list = [1,2,3,4]

# 使用 iter() 函数获取到列表的迭代器对象
it = iter(my_list)
# 解包
a,b,c,d = it

print(a)
# result => 1
print(b)
# result => 2
print(c)
# result => 3
print(d)
# result => 4

注意：如果列表元素个数未知，那么在进行序列解包时就要小心，不然会因为尝试解包的元素个数小于变量个数而抛出 ValueError 的异常！

使用序列解包遍历 enumerable 对象。

my_list = [1,2,3,4]

enumerabled = enumerable(my_list)

for item,index in enumerabled:
      print("位置：",index,"内容：",item)

字典

字典提供了一种灵活、高效的方式来存储和访问键值对的数据。

语法：

• 创建字典对象：dict = {‘name’ : 'Mark' , 'Age' : 25}
  • 使用 dict() 函数创建：my_dict = dict(name = 'Mark' , Age = 29)

keys = ['name' , 'age']
values = ['Lily' , '12']

res_dict = dict(zip(keys , values))
print(res_dict)

keys = ['name' , 'age']

res_dict = dict.fromKeys(keys)
print(res_dict)

# Result is {'name' : None , 'age' : None}

• 访问字典中的值：
  • 通过键访问值：print(dict['name'])
  • 使用 in 关键字来检查某个键是否存在于字典中：'name' in dict
  • 通过 get 函数来获取：dict.get("name")
    • dict.get(‘键’,‘如果没有该键对应的值则返回这里输入的内容’)：dict.get('name','Unkonwn')
  • 通过 items() 函数返回所有的键值对：dict.items()
  • 通过 keys() 函数返回所有的键：dict.keys()
  • 通过 values() 函数返回所有的值：dict.values()

my_dict = {'name' : 'Mark' , 'age' : 23}

item = my_dict.items()
key = my_dict.keys()
value = my_dict.values()

print(item)
# Result is [('name' , 'Mark') , ('age' , 23)]

print(key)
# Result is ['name' , 'age']

print(value)
# Result is ['Mark' , 23]

• 添加 / 修改字典元素：
  • 通过键来添加 / 修改：dict['score'] = 69
  • 调用 update() 函数：dict.update({'score' : 77})
  • 使用 del 关键字删除字典中指定的键值对：del dic['score']
  • 调用 pop() 函数删除并返回指定键的元素：dict.pop('score')
  • 调用 popitem() 函数随机删除字典中的一对键值对并以元组形式返回该键值对：dict.popitem()
  • 调用 clear() 函数清空字典中的所有键值对：dict.clear()
• 字典推导式：{key_expression for item in iterable}

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

# Result is {1:1 , 2:4 , 3:9 , 4:16}

集合

集合是一种无序且不重复的数据集合，可以用于存储多个唯一的元素。

语法：

• 创建集合：set = {1 , 2 , 3 , 4}
  • 空集合：set = {}
  • 调用 set() 函数：my_set = set([1 , 2 , 3 , 4 , 5])
    • 将字符串转换成集合：my_set = set("hello")
• 集合元素的添加 / 删除：
  • 使用 add() 函数添加元素：my_set.set("hello")
    • 注意：只可以添加不可变的元素，否则会报错。
  • 使用 pop() 函数随机删除一个元素：my_set.pop()
  • 使用 remove() 函数删除指定的元素：my_set.remove('hello')
  • 使用 clear() 函数清空整个集合元素：my_set.clear()
  • 使用 del 关键字删除整个集合： del my_set

集合的操作：

在 Python 中可以进行多种集合操作，如：子集、并集、交集、差集、对称差集等。

例如：

set1 = {1 , 2 , 3 , 4}
set2 = {3 , 4 , 5 , 6}

# 子集
print(set1.issubset(set2))
# Result is False

# 并集
print(set1.union(set2))
# Result is {1 , 2 ,3 ,4 , 5 , 6}

# 交集
print(set1.intersection(set2))
# Result is {3 , 4}

# 差集
print(set1.difference(set2))
# Result is {1 , 2}

# 对称差集
print(set1.symmeteric_difference(set2))
# Result is {1 , 2 , 5 , 6}

注意：以上这些操作都不会修改原始的集合，而是返回一个新的集合

字符串

字符串是 Python 中一种非常基础且重要的数据类型。

语法：

• 字符串的创建：str = 'Hello Word'
  • 扩展：字符串可以用 单引号 ' 或 双引号 " 括起来，当创建的字符串跨行、含有换行符或者制表符等特殊符号时用三个 单引号 '''
• 字符串元素的访问：
  • 通过下标访问：str[0]
    • 访问字符串的最后一个字符：str[-1]
  • 通过字符串切片访问：
    • str[0 , 5]：输出’Hello’
    • str[7 : ]：输出’Word’
    • str[ : 5]：输出’Hello’
    • str[-1]：输出’W’
• 字符串的常用内置函数：

函数	说明	函数	说明
str.isalpha()	是否全为字母	str.isupper()	是否全为大写
str.isdecimal()	是否只包含十进制数字字符	str.isnumeric()	是否只包含数字字符
str.isdigit()	是否全为数字（0 ~ 9）	str.isprintable()	是否只包含可打印字符
str.isidentifier()	是否是合法标识符	str.isspace()	是否只包含空白字符
str.islower()	是否全为小写	str.istitle()	是否为标题，即各单词首字母大小写
str.isalnum()	判断是一个字符串是否全为字母或是数字

# 判断是一个字符串是否全为字母或是数字
s1 = 'Hello123'
print(s1.isisalnum())    # True

# 是否全为字母
s2 = 'HelloWord'
print(s2.isalpha())      # True

# 是否只包含十进制数字字符
s3 = '123'
print(s3.isdemcial())    # True

# 是否全为数字（0 ~ 9）
s4 = '1234567890'
print(s4.isdigit())      # True

# 是否是合法标识符
s5 = '_name'
print(s5.isidentifier()) #True

# 是否全为小写
s6 = 'name'
print(s6.islower())      # True

# 是否全为大写
s7 = 'HELLO'
print(s7.isupper())      # True

# 是否只包含数字字符
print(s3.isnumeric())    # True

# 是否只包含可打印字符
print(s5.isprintable())  # True

# 是否只包含空白字符
s8 = ''
print(s8.isspace())      # True

# 是否为标题，即各单词首字母大小写
s9 = 'Hello,World!'
print(s9.istitle())      # True

函数	说明	函数	说明
str.capitalize()	转换为首字母大写，其余小写	str.swapcase()	大小写互换
str.lower()	转换为小写	str.title()	转换为各单词首字母大写
str.upper()	转换为大写	str.casefold()	转换为大小写无关字符串比较的格式字符串

# 转换为首字母大写，其余小写
s1 = 'hello,world'
print(s1.capitalize()) # Hello,World

# 转换为小写
s2 = 'Hello,World'
print(s2.lower())      # hello,world

# 转换为大写
print(s2.upper())      # HELLO,WORLD

# 大小写互换
print(s2.swapcase())   # hELLO,wORLD

# 转换为各单词首字母大写
print(s1.title())      # Hello,World

# 转换为大小写无关字符串比较的格式字符串
print(s2.casefold())   # hello,world

函数	说明
str.zfill(width)	左填充，用 0 填充到 width 长度
str.center(width [,fillchar])	两边填充，用 fillchar 字符（默认空格）填充到 width 长度
str.ljust(width [,fillchar])	左填充，用 fillchar 字符（默认空格）填充到 width 长度
str.rjust(width [,fillchar])	右填充，用 fillchar 字符（默认空格）填充到 width 长度
str.expandtabs([tabsize])	将字符串中的制表符扩展为若干个空格，tabsize 默认为8

#调用 zfill 函数将字符串填充为指定长度，不足部分用 0 填充
print("hello".zfill())                     # 00000hello

#调用 center 函数将字符串填充为指定长度，不足部分用 * 填充
print("hello".center(10, ‘*’))             # **hello***

#调用 ljust 函数将字符串填充为指定长度，不足部分用 * 填充
print("hello".ljust(10, '*'))              # hello*****

#调用 rjust 函数将字符串填充为指定长度，不足部分用 * 填充
print("hello".rjust(10, '*'))              # *****hello

#调用 expandtabs 函数将字符串填充中的制表符扩展为若干个空格
print("hello\tworld".expandtabs(10, '*'))  # hello world

函数	说明
str.startswith(prefix [,start [,end]])	是否以 prefix 开头
str.endswith(suffix [,start [,end]])	是否以 suffix 结尾
str.count(sub [,start [,end]])	返回指定字符串出现的次数
str.index(sub [,start [,end]])	搜索指定字符串，返回下标，没有则导致 ValueError 错误
str.rindex(sub [,start [,end]])	从右边开始搜索指定字符串，返回下标
str.find(sub [,start [,end]])	搜索指定字符串，返回下标，没有则返回 -1
str.rfind(sub [,start [,end]])	从右边开始搜索指定字符串，返回下标，没有则返回 -1
str.replace(old ,new [,count])	替换 old 为 new ，可选 count 为替换的最大次数

# 是否以 he 开头
print("hello world".startswith('he'))              # True

# 是否以 rld 结尾
print("hello world".endswith('rld'))               # True

# 返回指定字符串出现的次数
print("hello world".count('o'))                    # 2

# 搜索指定字符串，返回下标，没有则导致 ValueError 错误
print("hello world".index('o'))                    # 4

# 从右边开始搜索指定字符串，返回下标
print("hello world".rindex('o'))                   # 7

# 搜索指定字符串，返回下标，没有则返回 -1
print("hello world".find('e'))                     # 1

# 从右边开始搜索指定字符串，返回下标，没有则返回 -1
print("hello world".rfind('o'))                    # 7

# 替换 world 为 ,Python! ，可选 count 为替换的最大次数
print("hello world".replace(" world",",Python!"))  # hello,Python!

函数	说明
str.split(sep = None , maxsplite = -1)	按指定字符（默认为空格）分割字符串，返回列表；maxsplite 为最大分割次数，默认为 -1，无限制
str.rsplit(sep = None , maxsplite = -1)	从右侧按指定字符分割字符串，返回列表
str.partition(sep)	根据分隔符 sep ，分割字符串为左右两部分，返回元组（left，sep，right）
str.rpsrtition(sep)	根据分隔符 sep 从右分割字符串为两部分，返回元组（left，sep，right）
str.splitlines([keepends])	按行分割字符串，返回列表
str.join(iterable)	组合 iterable 中的各个元素成字符串，若包含非字符串元素，则导致 TypeError

my_str = "Hello, World!"

# 按空格分割字符串，返回列表；
print(my_str.splite())                    # ['Hello,','World!']

# 按指定字符","分割字符串，返回列表；
print(my_str.split(','))                  # ['Hello',' World!']

# 按指定字符"o"分割字符串，返回列表；
print(my_str.split('o'))                  # ['Hell',', W','rld!']

# 从右侧按指定字符分割字符串，返回列表
print(my_str.rsplit(','))                 # ['Hello',' World!']

# 根据分隔符"o"，分割字符串为左右两部分，返回元组
print(my_str.partition('o'))              # ('Hell','o',', World!')

# 根据分隔符"o"从右分割字符串为两部分，返回元组
print(my_str.rpartiition('o'))            # ('Hello,W','o','rld!')

# 按行分割字符串，返回列表
print(my_str.splitlines())                # ['Hello, World!']

# 组合 iterable 中的各个元素成字符串
iterable = ['hello' , '123' , 'world']
print(''.join(iterable))                  # TypeError

常量属性	说明
string.digits	常数
string.punctuation	标点符号
string.ascii_letters	英文字母
string.ascii_lowercase	小写字母
string.ascii_uppercase	大写字母

函数

函数是一段可复用的代码，他可以接收输入和输出。

函数的分类：

1. 内置函数
2. 标准库函数
3. 第三方库函数
4. 自定义函数

函数的定义：def 函数名([参数列表]): 函数体

说明：

1. 形参列表可有可无，且任何传入的参数必须放在圆括号内。
2. 函数可以使用 return [表达式] 语句返回值，函数中没有 return 语句相当于返回 None。

函数的调用：函数名([实参列表])

不定长参数

可变长度参数主要两种形式：

1. *parameter：用来接收多个实参并将其放在一个元组中
2. **parameter：接收关键参数并存放在字典中

fef getSum(*p):
      return sum(p)

getSum((1,2,3,4,5))

def printInfo(**p):
      for item in p.items:
            print(item)

info = {name = "mark" , age = 18}

print(printInfo(**info))

递归函数

在函数内部可以调用其他函数。如果一个函数在内部可以调用本身，那称之。

终止条件与递归步骤的两个主要部分：

1. 终止条件：表递归的借宿条件，用于返回函数值，不在递归调用。
2. 递归步骤：递归步骤把第 n 步的参数值的函数与第 n-1 步的参数值的函数关联。

匿名函数（lambda）

语法：name = lambda [参数列表] : 表达式

相比函数，lambda 表达式具有以下两种优势：

1. 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁。
2. 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能。

扩展用法：

• 与 map() 函数结合：
  • 作用：用于将一个函数应用于一个序列的所有元素，并返回一个迭代器。
  • 语法格式：map(function , iterable , ......)
    • fucntion：表示要勇于序列的函数，该函数需要接收一个或多个参数，并返回一个结果
    • iterable：表示一个序列（列表、元组、集合等）

it = map(lambda x: x**2,range(10))

print(list(it))
# Result is [0,1,4,9,16,25,36,49,64,81]

• 与 filter() 函数结合：(与 map() 函数用于相似)
  • 作用：用于将一个函数应用于一个序列的所有元素，并根据该函数返回一个迭代器，该迭代器包含所有使得函数返回 True 的元素。
  • 语法格式：filter(function , iterable , ......)

it = filter(lambda x: x**2,[i for i in range(10)])

print(list(it))
# Result is [0,1,4,9,16,25,36,49,64,81]

• 与 reduce() 函数结合：(与 map() 函数用于相似)
  • 作用：用于将一个二元函数应用于一个序列的所有元素，并逐步将序列中的元素缩减为单一的值。
  • 语法格式：reduce(fucntion , iterable , initial = None)
    • initial：缩减的初始值，如果提供，则第一次调用函数时使用该值作为第一个参数；如果未提供，则使用序列的第一个元素作为第一个参数（以此类推）

from functools import reduce

num = [1,2,3,4,5]
# 返回列表元素之积
res = reduce(lambda x , y : x*y , num)
# Result is 120