# 注释

• 单行注释

  # 注释内容

• 多行注释

  	""" 注释内容 """
  	''' 注释内容 '''

# 变量

# 变量的作⽤

变量就是⼀个存储数据的的时候当前数据所在的内存地址的名字

# 定义变量

变量 = 值

# 标识符

• 由 数字 、 字⺟ 、 下划线 组成

• 不能数字开头

• 不能使用内置关键字

• 严格区分大小写

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

# 命名习惯

• 见名知义
• 大驼峰：即每个单词首字⺟都大写，例如： MyName
• 小驼峰：第二个（含）以后的单词首字⺟大写，例如： myName
• 下划线：例如： my_name

# 认识数据类型

• 整型：int
• 浮点型：float
• 字符串：str
• 布尔型：bool
• 元组：tuple
• 集合：set
• 字典：dict

# 输出

# 格式化输出

所谓的格式化输出即按照⼀定的格式输出内容。

# 格式化符号

• %s：格式化输出字符串
• %d：格式化输出整数
• %f：格式化输出浮点数

# f - 字符串

• f'{表达式}'

# 转义字符

• \n：换行
• \t：制表符，，一个 tab 键（4 个空格）的距离

# print 结束符

print('内容', end="")

# 输入

# 输入的语法

• input (' 提示文字 ')

# 输入的特点

• 一般将 input 接收的数据存储到变量
• input 接收的任何数据默认都是字符串数据类型

# 转换数据类型

# 转换数据类型常用的函数

• int()
• float()
• str()
• list()
• tuple()
• eval()

# 运算符

# 分类

1. 算数运算符
2. 赋值运算符
3. 复合赋值运算符
4. 比较运算符
5. 逻辑运算符

# 算术运算符

# 赋值运算符

• 单个变量赋值

• 多个变量赋值

  	num1, float1, str1 = 10, 0.5, 'hello world'
  	print(num1)
  	print(float1)
  	print(str1)

• 多个变量赋相同值

  	a = b = 10
  	print(a)print(b)

# 复合赋值运算符

# 比较运算符

比较运算符也叫关系运算符， 通常用来判断。

# 逻辑运算符

# 扩展

数字之间的逻辑运算

a = 0

b = 1

c = 2

# and 运算符，只要有一个值为 0，则结果为 0，否则结果为最后一个非 0 数字

print(a and b)  # 0

print(b and a)  # 0

print(a and c)  # 0

print(c and a)  # 0

print(b and c)  # 2

print(c and b)  # 1

# or 运算符，只有所有值为 0 结果才为 0，否则结果为第一个非 0 数字

print(a or b)   # 1

print(a or c)   # 2

print(b or c)   # 1

# 条件语句

# if

if 条件:

    条件成立执行的代码1

    条件成立执行的代码2

    ......

# if...else...

作用：条件成立执行 if 下方的代码；条件不成立执行 else 下方的代码。

if 条件:

    条件成立执行的代码1

    条件成立执行的代码2

    ......

else:

    条件不成立执行的代码1

    条件不成立执行的代码2

    ......

# 多重判断

if 条件1:

    条件1成立执行的代码1

    条件2成立执行的代码2

    ......

elif 条件2：

	条件2成立执行的代码1

    条件2成立执行的代码2

    ............

else:

    以上条件都不成立执行执行的代码

# if 嵌套

if 条件1：

条件1成立执行的代码

条件1成立执行的代码

	if 条件2：

		条件2成立执行的代码

		条件2成立执行的代码

# if 嵌套执行流程

# 三目运算符

三目运算符也叫三元运算符或三元表达式。

语法如下：

条件成立执行的表达式 if 条件 else 条件不成立执行的表达式

# 循环

# while 的语法

while 条件:

    条件成立重复执行的代码1

    条件成立重复执行的代码2

    ......

# break 和 continue

break 和 continue 是循环中满足一定条件退出循环的两种不同方式。

• break 退出整个循环
• continue 退出本次循环，继续执行下一次重复执行的代码

# while 循环嵌套

while 条件1:

    条件1成立执行的代码

    ......

    while 条件2:

        条件2成立执行的代码

        ......

# 理解执行流程

当内部循环执行完成之后，再执行下一次外部循环的条件判断。

# for 循环

for 临时变量 in 序列:

    重复执行的代码1

    重复执行的代码2

    ......

# else

循环可以和 else 配合使用，else 下方缩进的代码指的是 当循环正常结束之后要执行的代码 。

# while...else

while 条件:

    条件成立重复执行的代码

else:

    循环正常结束之后要执行的代码

# for...else

for 临时变量 in 序列:

    重复执行的代码...

else:

    循环正常结束之后要执行的代码

• while 和 for 都可以配合 else 使用
• else 下方缩进的代码含义：当循环正常结束后执行的代码
• break终止循环不会执行else下方缩进的代码
• continue退出循环的方式执行else下方缩进的代码

# 字符串

# 认识字符串

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

# 字符串特征

• 一对引号字符串
• 三引号字符串

# 字符串输出

# 字符串输入

在 Python 中，使用 input() 接收用户输入。

# 下标

“下标” 又叫 “索引” ，就是编号

下标的作用即是通过下标快速找到对应的数据

# 切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

# 语法

序列[开始位置下标:结束位置下标:步长]

# 常用操作方法

字符串的常用操作方法有查找、修改和判断三大类。

# 查找

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。

• find() ：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回 - 1。

  语法：

  字符串序列.find(子串, 开始位置下标, 结束位置下标)

  注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

• index() ：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。

  语法：

  字符串序列.index(子串, 开始位置下标, 结束位置下标)

  注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

• rfind() ： 和 find () 功能相同，但查找方向为右侧开始。

• rindex() ：和 index () 功能相同，但查找方向为右侧开始。

• count() ：返回某个子串在字符串中出现的次数

  语法：

  字符串序列.count(子串, 开始位置下标, 结束位置下标)

  注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

# 修改

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。

• replace() ：替换

  语法：

  字符串序列.replace(旧子串, 新子串, 替换次数)

  注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

  注意：数据按照是否能直接修改分为 可变类型 和 不可变类型 两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

• split() ：按照指定字符分割字符串。

  语法：

  字符串序列.split(分割字符, num)

  注意：num 表示的是分割字符出现的次数，即将来返回数据个数为 num+1 个。

  注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。

• join() ：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

  语法：

  字符或子串.join(多字符串组成的序列)

• capitalize() ：将字符串第一个字符转换成大写。

  注意：capitalize () 函数转换后，只字符串第一个字符大写，其他的字符全都小写。

• title() ：将字符串每个单词首字⺟转换成大写。

• lower() ：将字符串中大写转小写。

• upper() ：将字符串中小写转大写。

• lstrip() ：删除字符串左侧空白字符。

• rstrip() ：删除字符串右侧空白字符。

• strip() ：删除字符串两侧空白字符。

• ljust() ：返回一个原字符串左对齐，并使用指定字符 (默认空格) 填充至对应长度 的新字符串。

  语法：

  字符串序列.ljust(长度, 填充字符)

• rjust() ：返回一个原字符串右对齐，并使用指定字符 (默认空格) 填充至对应长度 的新字符串，语法和 ljust () 相同。

• center() ：返回一个原字符串居中对齐，并使用指定字符 (默认空格) 填充至对应长度 的新字符串，语法和 ljust () 相同。

# 判断

所谓判断即是判断真假，返回的结果是布尔型数据类型： True 或 False 。

• startswith() ：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

  语法：

  字符串序列.startswith(子串, 开始位置下标, 结束位置下标)

• endswith() ：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

  语法：

  字符串序列.endswith(子串, 开始位置下标, 结束位置下标)

• isalpha() ：如果字符串至少有一个字符并且所有字符都是字⺟则返回 True, 否则返回 False。

• isdigit() ：如果字符串只包含数字则返回 True 否则返回 False。

• isalnum() ：如果字符串至少有一个字符并且所有字符都是字⺟或数字则返 回 True, 否则返回 False。

• isspace() ：如果字符串中只包含空白，则返回 True，否则返回 False。

# 列表

# 列表的格式

[数据1, 数据2, 数据3, 数据4......]

列表可以一次性存储多个数据，且可以为不同数据类型。

# 列表的常用操作

列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。

# 查找

# 下标

# 函数

• index() ：返回指定数据所在位置的下标 。

  语法：

  列表序列.index(数据, 开始位置下标, 结束位置下标)

  注意：如果查找的数据不存在则报错。

• count() ：统计指定数据在当前列表中出现的次数。

• len() ：访问列表长度，即列表中数据的个数。

# 判断是否存在

• in ：判断指定数据在某个列表序列，如果在返回 True，否则返回 False
• not in ：判断指定数据不在某个列表序列，如果不在返回 True，否则返回 False

# 增加

作用：增加指定数据到列表中。

• append() ：列表结尾追加数据。

  语法：

  列表序列.append(数据)

  列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。

  注意点

  如果 append () 追加的数据是一个序列，则追加 整个序列 到列表

• extend ()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

  语法：

  列表序列.extend(数据)

  1. 单个数据

     	name_list = ['Tom', 'Lily', 'Rose']
     	name_list.extend('xiaoming')
     	# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
     	print(name_list)

  2. 序列数据

     	name_list = ['Tom', 'Lily', 'Rose']
     	name_list.extend(['xiaoming', 'xiaohong'])
     	# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
     	print(name_list)

• insert ()：指定位置新增数据。

  语法：

  列表序列.insert(位置下标, 数据)

# 删除

• del

  语法：

  del 目标

  1. 删除列表

     	name_list = ['Tom', 'Lily', 'Rose']
     	# 结果：报错提示：name 'name_list' is not defineddel name_list
     	print(name_list)

  2. 删除指定数据

     	name_list = ['Tom', 'Lily', 'Rose']
     	del name_list[0]
     	# 结果：['Lily', 'Rose']
     	print(name_list)

• pop() ：删除指定下标的数据 (默认为最后一个)，并返回该数据。

  列表序列.pop(下标)

• remove() ：移除列表中某个数据的第一个匹配项。

  语法：

  列表序列.remove(数据)

• clear() ：清空列表

# 修改

• 修改指定下标数据

  	name_list = ['Tom', 'Lily', 'Rose']
  	name_list[0] = 'aaa'
  	# 结果：['aaa', 'Lily', 'Rose']
  	print(name_list)

• 逆置： reverse()

  	num_list = [1, 5, 2, 3, 6, 8]
  	num_list.reverse()
  	# 结果：[8, 6, 3, 2, 5, 1]
  	print(num_list)

• 排序： sort()

  语法：

  列表序列.sort( key=None, reverse=False)

  注意：reverse 表示排序规则，reverse = True 降序， reverse = False 升序（默认）

  # 复制

  函数： copy()

# 列表的循环遍历

需求：依次打印列表中的各个数据。

# while

name_list = ['Tom', 'Lily', 'Rose']

i = 0

while i < len(name_list):

    print(name_list[i])

    i += 1

# for

name_list = ['Tom', 'Lily', 'Rose']

for i in name_list:

    print(i)

# 列表嵌套

所谓列表嵌套指的就是一个列表里面包含了其他的子列表。

# 元组

# 元组的应用场景

一个元组可以存储多个数据，元组内的数据是 不能修改 的。

# 定义元组

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组

t1 = (10, 20, 30)

# 单个数据元组

t2 = (10,)

t2 = (10,)

print(type(t2)) # tuplet

3 = (20)

print(type(t3)) # int

t4 = ('hello')

print(type(t4)) # str

# 元组的常见操作

元组数据不支持修改，只支持查找，具体如下：

• 按下标查找数据

• index() ：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的 index 方法相同。

• count() ：统计某个数据在当前元组出现的次数。

• len() ：统计元组中数据的个数。

  注意：元组内的直接数据如果修改则立即报错

  	tuple1 = ('aa', 'bb', 'cc', 'bb')
  	tuple1[0] = 'aaa'

  但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。

  	tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
  	print(tuple2[2]) # 访问到列表
  	# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
  	tuple2[2][0] = 'aaaaa'
  	print(tuple2)

# 字典

# 创建字典的语法

字典特点：

• 符号为大括号

• 数据为键值对形式出现

• 各个键值对之间用逗号隔开

# 有数据字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 空字典

dict2 = {}

dict3 = dict()

# 字典常见操作

# 增

写法：字典序列 [key] = 值

# 删

• del() / del ：删除字典或删除字典中指定键值对。
• clear() ：清空字典

# 改

写法：字典序列 [key] = 值

# 查

# key 值查找

# get()

语法：

字典序列.get(key, 默认值)

# keys()

# values()

# items()

# 字典的循环遍历

# 遍历字典的 key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key in dict1.keys():

    print(key)

# 遍历字典的 value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value in dict1.values():

    print(value)

# 遍历字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for item in dict1.items():

    print(item)

# 遍历字典的键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key, value in dict1.items():

    print(f'{key} = {value}')

# 集合

# 创建集合

创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。

# 集合常⻅操作⽅法

# 增加数据

• add()

  因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。

• update() , 追加的数据是序列。

# 删除数据

• remove() ，删除集合中的指定数据，如果数据不存在则报错。
• discard() ，删除集合中的指定数据，如果数据不存在也不会报错。
• pop() ，随机删除集合中的某个数据，并返回这个数据。

# 查找数据

• in ：判断数据在集合序列
• not in ：判断数据不在集合序列

# 公共操作

# 运算符

# +

# 1. 字符串

str1 = 'aa'

str2 = 'bb'

str3 = str1 + str2

print(str3)  # aabb

# 2. 列表

list1 = [1, 2]

list2 = [10, 20]

list3 = list1 + list2

print(list3)  # [1, 2, 10, 20]

# 3. 元组

t1 = (1, 2)

t2 = (10, 20)

t3 = t1 + t2

print(t3)  # (1, 2, 10, 20)

# *

# 1. 字符串

print('-' * 10)  # ----------

# 2. 列表

list1 = ['hello']

print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']

# 3. 元组

t1 = ('world',)

print(t1 * 4)  # ('world', 'world', 'world', 'world')

# in 或 not in

# 1. 字符串

print('a' in 'abcd')  # True

print('a' not in 'abcd')  # False

# 2. 列表

list1 = ['a', 'b', 'c', 'd']

print('a' in list1)  # True

print('a' not in list1)  # False

# 3. 元组

t1 = ('a', 'b', 'c', 'd')

print('aa' in t1)  # False

print('aa' not in t1)  # True

# 公共方法

# enumerate()

语法：

enumerate(可遍历对象, start=0)

list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):

    print(i)

for index, char in enumerate(list1, start=1):

    print(f'下标是{index}, 对应的字符是{char}')

# 容器类型转换

# tuple()

作用：将某个序列转换成元组

# list()

作用：将某个序列转换成列表

# set()

作用：将某个序列转换成集合

# 推导式

# 列表推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。

列表推导式又叫列表生成式。

• 列表推导式

  	list1 = [i for i in range(10)]
  	print(list1)

# 带 if 的列表推导式

需求：创建 0-10 的偶数列表

• 方法一：range () 步长实现

  	list1 = [i for i in range(0, 10, 2)]
  	print(list1)

• 方法二：if 实现

  	list1 = [i for i in range(10) if i % 2 == 0]
  	print(list1)

# 多个 for 循环实现列表推导式

需求：创建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

• 代码如下：

  	list1 = [(i, j) for i in range(1, 3) for j in range(3)]
  	print(list1)

# 字典推导式

字典推导式作用：快速合并列表为字典或提取字典中目标数据。

1. 创建一个字典：字典 key 是 1-5 数字，value 是这个数字的 2 次方。

   	dict1 = {i: i**2 for i in range(1, 5)}
   	print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}

2. 将两个列表合并为一个字典

   	list1 = ['name', 'age', 'gender']
   	list2 = ['Tom', 20, 'man']
   	dict1 = {list1[i]: list2[i] for i in range(len(list1))}
   	print(dict1)

3. 提取字典中目标数据

   	counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
   	# 需求：提取上述电脑数量大于等于 200 的字典数据
   	count1 = {key: value for key, value in counts.items() if value >= 200}
   	print(count1) # {'MBP': 268, 'DELL': 201}

# 集合推导式

需求：创建一个集合，数据为下方列表的 2 次方。

list1 = [1, 1, 2]

set1 = {i ** 2 for i in list1}

print(set1) # {1, 4}

# 函数一

# 函数二

# 函数加强

# 文件操作