Python基础-变量、控制、函数、文件

注释

注释的作用

通过⽤⾃⼰熟悉的语⾔，在程序中对某些代码进⾏标注说明，这就是注释的作⽤，能够⼤
⼤增强程序的可读性
注释分为单行注释和多行注释

单行注释

以 # 开头，# 后面空格加注释内容

# 注释内容

多行注释，可以注释多行内容，一般用在注释一段代码的情况

"""
    第一行注释
    第二行注释
    第三行注释
"""
'''
    注释1
    注释2
    注释3
'''

变量

定义变量

变量名 = 值
变量名自定义，要满足标识符命名规则

标识符

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：
    由数字、字母、下划线组成
    不能数字开头
    不能使用内置关键字
    严格区分大小写

内置关键字

内置关键字
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 （浮点型）
布尔型：True（真） False（假）
str（字符串）
list（列表）
tuple（元组）
set（集合）
dict（字典）

类型检测

可以用内置函数type()

a = 1
print(type(a))  # <class 'int'> -- 整型
b = 1.1
print(type(b))  # <class 'float'> -- 浮点型
c = True
print(type(c))  # <class 'bool'> -- 布尔型
d = '12345'
print(type(d))  # <class 'str'> -- 字符串
e = [10, 20, 30]
print(type(e))  # <class 'list'> -- 列表
f = (10, 20, 30)
print(type(f))  # <class 'tuple'> -- 元组
h = {10, 20, 30}
print(type(h))  # <class 'set'> -- 集合
g = {'name': 'TOM', 'age': 20}
print(type(g))  # <class 'dict'> -- 字典

输入输出

输入

语法：
    input("提示信息")

当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理

password = input("请输入您的密码：")
print(f"您输入的密码是{password}")
print(type(password))

输出

格式化输出：所谓格式化输出即按照一定的格式输出内容
格式化字符串除了%s,还可以写为f"{表达式}"

格式化符号

格式符号	转换
%s	字符串
%d	有符号的⼗进制整数
%f	浮点数
%c	字符
%u	⽆符号⼗进制整数
%o	⼋进制整数
%x	⼗六进制整数（⼩写ox）
%X	⼗六进制整数（⼤写OX）
%e	科学计数法（⼩写’e’）
%E	科学计数法（⼤写’E’）
%g	%f和%e的简写
%G	%f和%E的简写

age = 18
name = 'TOM'
weight = 75.5
student_id = 1
# 我的名字是TOM
print('我的名字是%s' % name)
# 我的学号是0001
print('我的学号是%4d' % student_id)
# 我的体重是75.50公⽄
print('我的体重是%.2f公⽄' % weight)
# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

转义字符

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

结束符

两个print会换行输出，这是为社么呢？
因为在python中pring()函数，默认自带end='\n'这个换行结束符，所以导致每两个print直接会换行展示用户可以按需求更改结束符

print("输出内容", end="\t")

转换数据类型

转换数据类型的作用

问：input()接收⽤户输⼊的数据都是字符串类型，如果⽤户输⼊1，想得到整型该如何操作？
答：转换数据类型即可，即将字符串类型转换成整型。

转换数据类型的函数

函数	说明
int(x [,base ])	将x转换为⼀个整数
float(x )	将x转换为⼀个浮点数
complex(real [,imag ])	创建⼀个复数，real为实部，imag为虚部
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	⽤来计算在字符串中的有效Python表达式,并返回⼀个对象
tuple(s )	将序列 s 转换为⼀个元组
list(s )	将序列 s 转换为⼀个列表
chr(x )	将⼀个整数转换为⼀个Unicode字符
ord(x )	将⼀个字符转换为它的ASCII整数值
hex(x )	将⼀个整数转换为⼀个⼗六进制字符串
oct(x )	将⼀个整数转换为⼀个⼋进制字符串
bin(x )	将⼀个整数转换为⼀个⼆进制字符串

需求：input接收⽤户输⼊，⽤户输⼊“1”，将这个数据1转换成整型

# 1. 接收⽤户输⼊
num = input('请输⼊您的幸运数字：')
# 2. 打印结果
print(f"您的幸运数字是{num}")
# 3. 检测接收到的⽤户输⼊的数据类型 -- str类型
print(type(num))
# 4. 转换数据类型为整型 -- int类型
print(type(int(num)))

实践

# 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))
# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))
# 3. tuple() -- 将⼀个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 4. list() -- 将⼀个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

运算符

运算符的分类

算数运算符
赋值运算符
复合赋值运算符
⽐较运算符
逻辑运算符

算数运算符

运算符	描述	实例
+	加	1 + 1 输出结果为 2
-	减	1-1 输出结果为 0
*	乘	2 * 2 输出结果为 4
/	除	10 / 2 输出结果为 5
//	整除	9 // 4 输出结果为2
%	取余	9 % 4 输出结果为 1
**	指数	2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
()	⼩括号	⼩括号⽤来提⾼运算优先级，即 (1 + 2) * 3 输出结果为 9

注意：混合运算优先级顺序：() ⾼于 ** ⾼于 * / // % ⾼于 + -

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等价于 c = c + a
-=	减法赋值运算符	c -= a 等价于 c = c- a
*=	乘法赋值运算符	c *= a 等价于 c = c * a
/=	除法赋值运算符	c /= a 等价于 c = c / a
//=	整除赋值运算符	c //= a 等价于 c = c // a
%=	取余赋值运算符	c %= a 等价于 c = c % a
**=	幂赋值运算符	c ** = a 等价于 c = c ** a

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

运算符	描述	实例
==	判断相等。如果两个操作数的结果相等，则条件结 果为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True
!=	不等于 。如果两个操作数的结果不相等，则条件为 真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True如 a=1,b=3，则(a != b) 为 True
>	运算符左侧操作数结果是否⼤于右侧操作数结果， 如果⼤于，则条件为真，否则为假	如a=7,b=3，则(a > b) 为 True
<	运算符左侧操作数结果是否⼩于右侧操作数结果， 如果⼩于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False
>=	运算符左侧操作数结果是否⼤于等于右侧操作数结 果，如果⼤于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False如 a=3,b=3，则(a >= b) 为 True
<=	运算符左侧操作数结果是否⼩于等于右侧操作数结 果，如果⼩于，则条件为真，否则为假	如a=3,b=3，则(a <= b) 为 True

a = 7
b = 5
print(a == b)  # False
print(a != b)  # True
print(a < b)  # False
print(a > b)  # True
print(a <= b)  # False
print(a >= b)  # True

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。	True and False， 返回 False。
or	x or y	布尔"或"：如果 x 是 True，它返回 True，否则 它返回 y 的值。	False or True， 返回 True。
not	not x	布尔"⾮"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not True 返回 False, not False 返回 True

条件语句

条件语句：条件成立执行某些代码，条件不成立则不执行这些代码
if语法：
    if 条件：
        条件成⽴执⾏的代码1
        条件成⽴执⾏的代码2
if...else语法
    if 条件：
        条件成立执行的代码
    else：
        条件不成立执行的代码
多重判断语法：
    if 条件1:
        条件1成⽴执⾏的代码1
        条件1成⽴执⾏的代码2
        ......
    elif 条件2：
        条件2成⽴执⾏的代码1
        条件2成⽴执⾏的代码2
        ......
    ......
    else:
        以上条件都不成⽴执⾏执⾏的代码
if嵌套语法：
    if 条件1：
         条件1成⽴执⾏的代码
         条件1成⽴执⾏的代码
    if 条件2：
         条件2成⽴执⾏的代码
         条件2成⽴执⾏的代码
三目运算符语法:
    条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

a = 1
b = 2
c = a if a > b else b
print(c)

循环

循环的作用：让代码更高效的重复执行
循环的分类：循环分为while 和 for两种，最终实现效果相同
while语法:
    while 条件：
        条件成⽴重复执⾏的代码1
        条件成⽴重复执⾏的代码2
break 和 continue是循环中满足一定条件退出循环的两种不同的方式
break：满足条件终止循环，后面的不再执行
continue：退出当前一次循环继而执行下一次循环代码
while嵌套循环语法：
    while 条件1:
        条件1成⽴执⾏的代码
        ......
    while 条件2:
        条件2成⽴执⾏的代码
        ......
for循环语法：
    for 临时变量 in 序列：
        重复执行的代码1
        重复执行的代码2
循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码，如果是break终止循环的情况，else下方缩进的代码将不执行
while...else语法：
    while 条件:
        条件成⽴重复执⾏的代码
    else:
        循环正常结束之后要执⾏的代码
for...else语法：
    for 临时变量 in 序列:
        重复执⾏的代码
        ...
    else:
        循环正常结束之后要执⾏的代码

字符串

字符串特征

 一对引号字符串
    "Jerry"
 三引号字符串
    """i am Jerry 
        nice to meet you
    """

下标

“下标” ⼜叫 “索引” ，就是编号。⽐如⽕⻋座位号，座位号的作⽤：按照编号快速找到对应的座位。同理，下标的作⽤即是通过下标快速找到对应的数据。
下标是从0开始的

切片

语法：
    序列[开始位置下标:结束位置下标:步⻓]
注意：
    不包含结束位置下标对应的数据， 正负整数均可；
    步⻓是选取间隔，正负整数均可，默认步⻓为1。

name = "abcdefg"
print(name[2:5:1])  # cde
print(name[2:5])  # cde
print(name[:5])  # abcde
print(name[1:])  # bcdefg
print(name[:])  # abcdefg
print(name[::2])  # aceg
print(name[:-1])  # abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1])  # def
print(name[::-1])  # gfedcba

字符串常用操作

查找

find():检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
语法：
    字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
语法：
    字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

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

count()：返回某个⼦串在字符串中出现的次数
语法：
    字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

修改

replace():替换
语法：
    字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候
不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

split(): 按照指定字符分割字符串
语法：
    字符串序列.split(分割字符, num)
注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
语法：
    字符或⼦串.join(多字符串组成的序列)

capitalize()：将字符串第⼀个字符转换成⼤写。
语法：
    字符串.capitalize()
注意：capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。

title()：将字符串每个单词⾸字⺟转换成⼤写。
语法：
    字符串.title()

lower()：将字符串中⼤写转⼩写。
语法：
    字符串.lower()

upper()：将字符串中⼩写转⼤写。
语法：
    字符串.upper()

lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。

ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串。
语法：
    字符串序列.ljust(⻓度, 填充字符)
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串，语法和ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串，语法和ljust()相同。

判断

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

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

isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。
isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。

列表

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

列表的常用操作

列表的作⽤是⼀次性存储多个数据，可以对这些数据进⾏的操作有：增、删、改、查。

查找

下标：
    list[0],也可遵循切片的原则

函数：
    index()：返回指定数据所在位置的下标 。
    count()：统计指定数据在当前列表中出现的次数。
    len()：访问列表⻓度，即列表中数据的个数。

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

增加

append()：列表结尾追加数据。
    列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据。
    如果append()追加的数据是⼀个序列，则追加整个序列到列表

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

insert()：指定位置新增数据。
    语法：
        列表序列.insert(位置下标, 数据)

删除

del 目标列表：会直接删除整个列表
del 目标列表[0]: 会删除列表中第一个元素
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
remove()：移除列表中某个数据的第⼀个匹配项。
clear()：清空列表，清空列表的所有元素，剩下空列表

修改

列表[0] = "aaa": 修改执行下标数据，这里是修改第一个元素为 aaa
reverse(): 逆置，将列表倒数第一个元素放到第一位，倒数第二个元素放到第二位，以此类推

sort()：排序
    语法：
        列表序列.sort(key=None, reverse=False)
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

复制

函数copy(): new_list = list.copy()

列表嵌套

所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表。 
    name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]

元组

一个元组可以存储多个数据，元组内的数据是不能修改的
元组的特点：
    定义元组使用小括号()，且使用逗号隔开各个数据，数据可以是不同的数据类型
        t1 = (10,20,30)
        t2 = (10,)
注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型

元组的常见操作

按下标查找数据
    tuple1[0], 此时查询的是元组的第一个元素
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。
count()：统计某个数据在当前元组出现的次数。
count()：统计某个数据在当前元组出现的次数。
注意：元组内的直接数据如果修改则⽴即报错，但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要。

字典

字典，字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标，后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可。
字典是可变类型

创建字典的语法

符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开
注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()

字典的常见操作
增

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

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

删

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

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

clear():清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

改

写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。

查

key值查找,如果当前查找的key存在，则返回对应的值；否则则报错。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name'])  # Tom
print(dict1['id'])  # 报错

get()：
    字典序列.get(key, 默认值)
注意：如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None

keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())  # dict_values(['Tom', 20, '男'])

items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])

集合

创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
特点：
    集合可以去掉重复数据
    集合数据是⽆序的，故不⽀持下标

创建集合

s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)
s3 = set('abcdefg')
print(s3)
s4 = set()
print(type(s4))  # set
s5 = {}
print(type(s5))  # dict

集合的常见操作
增

add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}

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

s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

删

remove()，删除集合中的指定数据，如果数据不存在则报错。

s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10)  # 报错
print(s1)

discard()，删除集合中的指定数据，如果数据不存在也不会报错。

s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)

pop()，随机删除集合中的某个数据，并返回这个数据。

s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)

查

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

s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)

公共操作

运算符

运算符	描述	⽀持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
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)  # (10, 20, 100, 200)

运算符*

# 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

公共方法

函数	描述
len()	计算容器中元素个数
del或del()	删除
max()	返回容器中元素最⼤值
min()	返回容器中元素最⼩值
range(start, end, step)	⽣成从start到end的数字，步⻓为 step，供for循环使⽤
enumerate()	函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序列， 同时列出数据和数据下标，⼀般⽤在 for 循环当中。

len()

# 1. 字符串
str1 = 'abcdefg'
print(len(str1))  # 7
# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1))  # 4
# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1))  # 5
# 4. 集合
s1 = {10, 20, 30}
print(len(s1))  # 3
# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

del()

# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del (list1[0])
print(list1)  # [20, 30, 40]

max()

# 1. 字符串
str1 = 'abcdefg'
print(max(str1))  # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1))  # 40

min()

# 1. 字符串
str1 = 'abcdefg'
print(min(str1))  # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1))  # 10

range()

注意：range()⽣成的序列不包含end数字。

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i)

enumerate()

语法：
    enumerate(可遍历对象, start=0)
    注意：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()

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

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))

list()

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

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))

set()

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

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))

集合可以快速完成列表去重,集合不⽀持下标

推导式

列表推导式

作⽤：⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。列表推导式⼜叫列表⽣成式。

while循环实现

# 1. 准备⼀个空列表
list1 = []
# 2. 书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)

for循环实现

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

列表推导式实现

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)

字典推导式

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

创建⼀个字典：字典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}

将两个列表合并为⼀个字典

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

提取字典中⽬标数据

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]

list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1)  # {1, 4}

注意：集合有数据去重功能。

函数

函数的作用

函数就是将⼀段具有独⽴功能的代码块 整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对应的需求。
函数在开发过程中，可以更⾼效的实现代码重⽤。

函数的使用步骤

定义函数

def 函数名(参数):
    代码1
    代码2
    ......

调用函数

函数名(参数)
不同的需求，参数可有可⽆。
在Python中，函数必须先定义后使⽤。

函数的参数作用

完成需求如下：⼀个函数完成两个数1和2的加法运算，如何书写程序？

# 定义函数
def add_num1():
    result = 1 + 2
    print(result)


# 调⽤函数
add_num1()

思考：上述add_num1函数只能完成数字1和2的加法运算，如果想要这个函数变得更灵活，可以计算任
何⽤户指定的两个数字的和，如何书写程序？
分析：⽤户要在调⽤函数的时候指定具体数字，那么在定义函数的时候就需要接收⽤户指定的数字。函
数调⽤时候指定的数字和定义函数时候接收的数字即是函数的参数。

# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
def add_num2(a, b):
    result = a + b
    print(result)


# 调⽤函数时传⼊了真实的数据10 和 20，真实数据为实参
add_num2(10, 20)

函数的返回值作用

例如：我们去超市购物，⽐如买烟，给钱之后，是不是售货员会返回给我们烟这个商品，在函数中，如果需要返回结果给⽤户需要使⽤函数返回值。

def buy():
    return '烟'


# 使⽤变量保存函数返回值
goods = buy()
print(goods)

需求：制作⼀个计算器，计算任意两数字之和，并保存结果。

def sum_num(a, b):
    return a + b


# ⽤result变量保存函数返回值
result = sum_num(1, 2)
print(result)

函数的说明文档

函数的说明⽂档也叫函数的⽂档说明。
语法：
    def 函数名(参数):
         """ 说明⽂档的位置 """
         代码
         ......
查看函数的说明文档
    help(函数名)

def sum_num(a, b):
    """ 求和函数 """
    return a + b


help(sum_num)

函数嵌套调用

所谓函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数。

def testB():
    print('---- testB start----')
    print('这⾥是testB函数执⾏的代码...(省略)...')
    print('---- testB end----')


def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')


testA()

变量作用域

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。
局部变量：
    所谓局部变量是定义在函数体内部的变量，即只在函数体内部⽣效。
局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量。

def testA():
    a = 100
    print(a)


testA()  # 100
print(a)  # 报错：name 'a' is not defined
# 变量a是定义在 testA 函数内部的变量，在函数外部访问则⽴即报错。

全局变量
    所谓全局变量，指的是在函数体内、外都能⽣效的变量。

# 定义全局变量a
a = 100


def testA():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


def testB():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


testA()  # 100
testB()  # 100

函数内修改全局变量需要通过global关键字

a = 100


def testA():
    print(a)


def testB():
    # global 关键字声明a是全局变量
    global a
    a = 200
    print(a)


testA()  # 100
testB()  # 200
print(f'全局变量a = {a}')  # 全局变量a = 200

多函数程序执行流程

⼀般在实际开发过程中，⼀个程序往往由多个函数（后⾯知识中会讲解类）组成，并且多个函数共享某些数据，如下所示
共用全局变量

# 1. 定义全局变量
glo_num = 0


def test1():
    global glo_num
    # 修改全局变量
    glo_num = 100


def test2():
    # 调⽤test1函数中修改后的全局变量
    print(glo_num)


# 2. 调⽤test1函数，执⾏函数内部代码：声明和修改全局变量
test1()
# 3. 调⽤test2函数，执⾏函数内部代码：打印
test2()  # 100

返回值作为参数传递

def test1():
    return 50


def test2(num):
    print(num)


# 1. 保存函数test1的返回值
result = test1()
# 2.将函数返回值所在变量作为参数传递到test2函数
test2(result)  # 50

函数返回多个值

def return_num():
    return 1, 2


result = return_num()
print(result)  # (1, 2)

注意：
    return a, b 写法，返回多个数据的时候，默认是元组类型。
    return后⾯可以连接列表、元组或字典，以返回多个值。

函数的参数

位置参数：调⽤函数时根据函数定义的参数位置来传递参数。
注意：传递和定义参数的顺序及个数必须⼀致。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')

关键字参数：函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求。
注意：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间不存在先后顺序。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='⼥')
user_info('⼩明', gender='男', age=16)

缺省参数：缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值
    （注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）。
注意：函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '⼥')

不定长参数：不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，
    可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便。
包裹位置传递
注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递。

def user_info(*args):
    print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

包裹关键字传递

def user_info(**kwargs):
    print(kwargs)


# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

综上：⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程。

拆包

拆包：元组

def return_num():
    return 100, 200


num1, num2 = return_num()
print(num1)  # 100
print(num2)  # 200

拆包：字典

dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
# 对字典进⾏拆包，取出来的是字典的key
print(a)  # name
print(b)  # age
print(dict1[a])  # TOM
print(dict1[b])  # 18

交换变量值

需求：有变量 a = 10 和 b = 20 ，交换两个变量的值。
⽅法⼀：借助第三变量存储数据。

a = 10
b = 20
# 1. 定义中间变量
# 2. 将a的数据存储到c
c = a
# 3. 将b的数据20赋值到a，此时a = 20
a = b
# 4. 将之前c的数据10赋值到b，此时b = 10
b = c
print(a)  # 20
print(b)  # 10

方法二：

a,b = 10,20
a,b = b,a
print(a)
print(b)

引用

了解引用

在python中，值是靠引⽤来传递来的。
我们可以⽤ id() id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识。

# 1. int类型
a = 1
b = a
print(b) # 1
print(id(a)) # 140708464157520
print(id(b)) # 140708464157520
a = 2
print(b) # 1,说明int类型为不可变类型
print(id(a)) # 140708464157552，此时得到是的数据2的内存地址
print(id(b)) # 140708464157520
# 2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432
aa.append(30)
print(bb) # [10, 20, 30], 列表为可变类型
print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432

引⽤当做实参

def test1(a):
    print(a)
    print(id(a))
    a += a
    print(a)
    print(id(a))


# int：计算前后id值不同
b = 100
test1(b)
# 列表：计算前后id值相同
c = [11, 22]
test1(c)

可变类型与不可变类型

所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.

可变类型

列表、字典、集合

不可变类型

整形、浮点型、字符串、元组

递归
递归的应用场景

递归是⼀种编程思想，应⽤场景：
    在我们⽇常开发中，如果要遍历⼀个⽂件夹下⾯所有的⽂件，通常会使⽤递归来实现；
    算法离不开递归，例如：快速排序。

递归的特点

函数内部⾃⼰调⽤⾃⼰
必须有出⼝

代码示例:3以内数字累加和

# 3 + 2 + 1
def sum_numbers(num):
    # 1.如果是1，直接返回1 -- 出⼝
    if num == 1:
        return 1
    # 2.如果不是1，重复执⾏累加:
    result = num + sum_numbers(num - 1)
    # 3.返回累加结果
    return result


sum_result = sum_numbers(3)
# 输出结果为6
print(sum_result)

lambda表达式
lambda应用场景

如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化。
lambda语法：
    lambda 参数列表: 表达式
注意：
    lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。
    lambda函数能接收任何数量的参数但只能返回⼀个表达式的值

简单示例代码

# 函数
def fn1():
    return 200


print(fn1)
print(fn1())
# lambda表达式
fn2 = lambda: 100
print(fn2)
print(fn2())

注意：直接打印lambda表达式，输出的是此lambda的内存地址

示例：计算a + b

函数实现

def add(a, b):
    return a + b


result = add(1, 2)
print(result)

lambda实现

print((lambda a, b: a + b)(1, 2))

lambda的参数形式

无参数

print((lambda: 100)())

一个参数

print((lambda a: a)('hello world'))

默认参数

print((lambda a, b, c=100: a + b + c)(10, 20))

可变参数：**args
注意：这⾥的可变参数传⼊到lambda之后，返回值为元组。

print((lambda *args: args)(10, 20, 30))

可变参数：**kwargs

print((lambda **kwargs: kwargs)(name='python', age=20))

lambda的应用

带判断的lambda

print((lambda a, b: a if a > b else b)(1000, 500))

列表数据按字典key的值排序

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}]
# 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)
# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

高阶函数

把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现。函数式编程就是指这种⾼度抽象的编程范式。
需求：⼀个函数完成计算任意两个数字的绝对值之和。
在Python中， abs() 函数可以完成对数字求绝对值计算。
方法一

def add_num(a, b):
    return abs(a) + abs(b)


result = add_num(-1, 2)
print(result)  # 3

方法二

def sum_num(a, b, f):
    return f(a) + f(b)


result = sum_num(-1, 2, abs)
print(result)  # 3

注意：两种⽅法对⽐之后，发现，⽅法2的代码会更加简洁。
函数式编程⼤量使⽤函数，减少了代码的重复，因此程序⽐较短，开发速度较快。

内置高阶函数

map()

map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。
需求：计算 list1 序列中各个数字的2次⽅。

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


def func(x):
    return x ** 2


result = map(func, list1)
print(result)  # <map object at 0x0000013769653198>
print(list(result))  # [1, 4, 9, 16, 25]

reduce()

reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。
注意：reduce()传⼊的参数func必须接受2个参数。
需求：计算 list1 序列中各个数字的累加和。

import functools

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


def func(a, b):
    return a + b


result = functools.reduce(func, list1)
print(result)  # 15

filter()

filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象,。如果要转换为列表,可以使⽤ list() 来转换。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def func(x):
    return x % 2 == 0


result = filter(func, list1)
print(result)  # <filter object at 0x0000017AF9DC3198>
print(list(result))  # [2, 4, 6, 8, 10]

文件操作

⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒。

文件的基本操作

打开⽂件
读写等操作
关闭⽂件
在python，使⽤open函数，可以打开⼀个已经存在的⽂件，或者创建⼀个新⽂件，语法如下：
    open(name,mode)
    name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
    mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等。

打开文件模式

模式	描述
r	以只读⽅式打开⽂件。⽂件的指针将会放在⽂件的开头。这是默认模式。
rb	以⼆进制格式打开⼀个⽂件⽤于只读。⽂件指针将会放在⽂件的开头。这是默认模式。
r+	打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。
rb+	以⼆进制格式打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。
w	打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内 容会被删除。如果该⽂件不存在，创建新⽂件。
wb	以⼆进制格式打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编 辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。
w+	打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容 会被删除。如果该⽂件不存在，创建新⽂件。
wb+	以⼆进制格式打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编 辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。
a	打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说， 新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。
ab	以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结 尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进 ⾏写⼊。
a+	打开⼀个⽂件⽤于读写。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。⽂件打开时 会是追加模式。如果该⽂件不存在，创建新⽂件⽤于读写。
ab+	以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。如果该⽂件不存在，创建新⽂件⽤于读写。

文件对象方法

写

语法：对象.write("内容")

# 1. 打开⽂件
f = open('test.txt', 'w')
# 2.⽂件写⼊
f.write('hello world')
# 3. 关闭⽂件
f.close()

注意：
    w和a模式：如果⽂件不存在则创建该⽂件；如果⽂件存在， w 模式先清空再写⼊， a 模式直接末尾追加。
    r模式：如果⽂件不存在则报错。

读

read()
    文件对象.read(num)
    num表示要从⽂件中读取的数据的⻓度（单位是字节），如果没有传⼊num，那么就表示读取⽂件中所有的数据。
readlines()
readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。

f = open('test.txt')
content = f.readlines()
# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)
# 关闭⽂件
f.close()

readline()
readline()⼀次读取⼀⾏内容。

f = open('test.txt')
content = f.readline()
print(f'第⼀⾏：{content}')
content = f.readline()
print(f'第⼆⾏：{content}')
# 关闭⽂件
f.close()

seek()作⽤：⽤来移动⽂件指针。
语法如下：
    ⽂件对象.seek(偏移量, 起始位置)
    起始位置：
        ⽂件开头
        当前位置
        ⽂件结尾

关闭

文件对象.close()

文件和文件夹的操作

在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：
    导⼊os模块
        import os
    使⽤ os 模块相关功能
        os.函数名()
文件重命名
    os.rename(目标文件名,新文件名)

删除文件
    os.remove(目标文件名)

创建文件夹
    os.mkdir(文件夹名字)

删除文件夹
    os.rmdir(文件夹名字)

获取当前目录
    os.getcwd()

改变默认目录
    os.chdir(目录)

获取目录列表
    os.listdir(目录)