Python 笔记

以前学py的时候做的笔记，以此检索

1、计算机组成原理和python基础知识

1.1、计算机组成原理

1.2、编程语言和python

1.3、使用pycharm编写第一个程序

1.3.1、新建工程

1.3.2、新建.py文件

1.3.3、运行python程序

1.4、注释

1.4.1、单行注释

以 # 开头

print("hello world")#单行注释

单行注释快捷键 CTRL + /

1.4.2、多行注释

以 “““ 开头 以 ””” 结尾 （单引号也可以）

"""
多行注释1
多行注释2
"""

print("hello world")

'''
多行注释3
多行注释4
'''

1.5、标识符 和 关键字

1.5.1、标识符

命名规则：以数字、字母、下划线组成，并且数字不能开头。

​ 大小写敏感。

​ 不能使用python内置关键字

命名习惯：见名知意

​ 大（小）驼峰命名法

​ 以下划线来区分单词

PEP8 python 命名规则

1.5.2、关键字

'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 
'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'

1.6、变量以及类型

变量的作用：存储数据

1.6.1、变量的定义

需符合标识符命名规则

# 第一步，定义变量。语法 ： 变量名 = 值
my_name = "fairy"
message = "hello world"

# 第二部，使用变量
print(my_mane)
print(message)

1.6.2、变量的类型

python不需要程序员指定数组类型，CPU自动识别。

可用type查看变量的数据类型

age = 20
print(type(age))
#输出 ：<class 'int'>

快速复制快捷键 CTRL + D

1.7、输出语句

1.7.1、格式化输出

age = 20
name = "fairy"
weight = 104.65

print("我的姓名是%s，我的年龄是%d，我的体重是%.1f。" % (name, age,weight))

#输出 我的姓名是fairy，我的年龄是20，我的体重是104.7。

%.1f 保留一位小数 ，多余位 四舍五入

1.7.2、关于换行输出

python的print语句默认自带换行，即end = ‘\n’ 。可以人为修改。

print(11111)
print(22222)
#输出 
#   11111 
#   22222

print(11111,end=' ')#引号中间是空格
print(22222)
#输出 11111 22222

1.8、输入语句

1.8.1、input（）

输入的数据都是字符串

#语法： input ("提示信息")
#特点：输入的数据类型均为 字符串 str
#举例：

age = input("input your age")

print(age)

print(type(age))

#输出 input your age20
#    20
#    <class 'str'>

1.9、数据类型转换

str1 = '1'
str2 = '1.1'
num = 10

# 1、int()
# 将括号里的转换成整型
print(type(int(str1)))
# 2、int()
# 将括号里的转换成浮点型
print(type(float(str2)))
# 3、str()
# 将括号里的转换成字符串
print(type(str(num)))
# 4、eval() 
# 将字符串数据恢复成字符串里面的类型，相当于去掉引号
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(num)))  #错误，只针对字符串

'''
输出
<class 'int'>
<class 'float'>
<class 'str'>

<class 'int'>
<class 'float'>
'''

1.10、运算符

1.10.1、算术运算符

加、减、乘、除、整除、取余、指数

num1 = 9
num2 = 2
num3 = 3

print(num1 + num2)		#11		加法
print(num1 - num2)		#7		减法
print(num1 * num2)		#18		乘法
print(num1 / num2)		#4.5	除法
print(num1 // num2)		#4		整除

print(num1 % num2)		#1		取余
print(num1 ** num2)		#81		指数

print(num1 / num3)		#3.0	除法运算的结果都是整数

1.10.2、赋值运算符

a, b, c = 1, 2, 3	#依次对应赋值
print(a)		#1
print(b)		#2
print(c)		#3

1.10.3、复合赋值运算

-=
+=
*=
/=
%=

1.10.4、比较运算符

>
<
>=
<=
==
!=

1.10.5、逻辑运算符

and		#逻辑与
or		#逻辑或
not		#逻辑非

2、判断语句 和 循环语句

2.1、if 条件语句

作用：条件判断、流程控制

2.1.1、if 语句

'''
if 条件:
	条件为真执行的代码
'''
if True :
    print("The condition is True")

2.1.2、Debug工具

2.1.3、if…else…语句

'''
if 条件:
    条件为真执行的代码
else:
    条件为假执行的代码
'''

2.1.4、if…elif…else…语句

'''
if condition1:
	code 1
elif condition2:
	code 2
elif condition3:
	code 3
else:
	code 4
'''

score = int(input("Please input your score:"))

if 90 <= score <= 100:
    print("Your grade is A")

elif 80 <= score <= 90:
    print("Your grand is B")

elif 70 <= score <= 80:
    print("Your grand is C")

elif 60 <= score <= 70:
    print("Your grand is D")

else:
    print("Your grand is E")

2.1.5、if 嵌套

if ticket == 1:
    print("Oh,that is great!")
    seat = int(input("Are there any seats on the bus?(1 or 0)"))
    if seat == 1:
        print("OK,you can seat in your seat.")
    else:
        print("All right,you have to stand.")
else:
    print("Emm,that is pity!")

2.1.6、三目运算符

化简 if … else …

'''
代码格式
条件为真执行的代码 if 条件 else 条件为假执行的代码

要求
代码最好是一条语句，多了不好
'''

age = int(input('input your age'))
print("It is Ok!") if age >= 18 else print("It is NOT OK!")

2.1.7、小案例：石头剪刀布

要求：玩家输入数字代表石头剪刀布的一种，电脑随机输出。然后判断输赢

#石头1 、剪刀2、布3、
print("石头1 、剪刀2、布3")

#玩家出拳
player = int(input("It is your turn.Input:"))

#电脑出拳
computer = 1

#判定输赢
if player == computer:
    print("your is %d,and the computer is %d" % (player, computer))
    print("It ends in a draw.")
elif (player == 2 and computer == 1) or (player == 3 and computer == 2) or (player == 1 and computer == 3):
    print("your is %d,and the computer is %d" % (player, computer))
    print("The computer win.")
else:
    print("your is %d,and the computer is %d" % (player, computer))
    print("The player win!")

2.1.8、随机数

1、导入 random 模块

2、使用 randint 功能实现随机数

import random
num = random.randint(1, 5)#范围：1~5

2.2、循环语句

2.2.1、while 语法

'''
while 条件:
	条件为真循环的代码
'''

while True:
    print("It is True.")

2.2.2、while 配合计数器

i = 0			#初始值
while i <= 5:	 #最大值
    print("This is %d" % i)
    i += 1		#自增量

2.2.3、while循环应用

# 求 1+2+3+...+100 = ?

i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print("The sum is %d." % sum)

# 求 2+4+6+...+100 = ?

# way 1
i = 1
sum = 0
while i <= 100:
    if i % 2:
        #pass 可跳过
        sum += i
    i += 1
print("The sum is %d." % sum)

# way 2

j = 2
j_sum = 0
while j <= 100:
    j_sum += j
    j +=2
print("The j_sum is %d" % j_sum)

2.2.4、while 循环嵌套

while 条件1:

​ 条件1真执行的代码

​ while 条件2：

​ 条件2真执行的代码

# 嵌套循环输出 九九乘法表
i = 1
while i <= 9:
    j = 1
    while i >= j:
        print("%2dX%-2d=%2d" % (i, j, i*j), end='\t')
        j += 1
    i += 1
    print("\n", end=' ')

3、循环 & 容器类型

3.1、循环

3.1.1、for 循环

作用：一般配合容器类型，用来遍历整个容器类型

语法：
for 临时变量 in 列表或者字符串等可迭代对象
	循环满足条件时执行的代码

str1 = "asd jkl"
for char in str1:
    print(char)
#输出七行字符

3.1.2、range()

作用：函数，生成一个整数数据的可迭代对象（整数数据的序列）

语法：range(开始数字，结束数字，步长)

即可生成左闭右开的数据。

开始数字可省略，则默认从0开始

步长可以省略，则默认为1

生成的序列不包含结束数字

for num in range(1, 10, 1):
    print(num)
# 输出1~~9
for num in range(1, 10):
    print(num)
# 输出1~~9
for num in range(10):
    print(num)
# 输出0~~9
print(range(1, 10, 1))  # 在Python3中, range打印结果(内存存储)为一个序列, 为的是节省内存的开销

3.1.3、break & continue

作用：在循环中，满足一定条件时退出循环的两种方式

str1 = "abcdefg"
for i in str1:
    if i == "d":
        break
    print(i)
# 输出 abc

for i in str1:
    if i == "d":
        continue
    print(i)
# 输出 abcefg (没有d)

3.1.4、循环的 else

作用：当循环正常结束（不是被break结束）后执行 else 下方缩进的代码

例如循环输入密码，正确了break，如果循环次数都用完了还不对，就执行else下面的锁定账号的代码

user_A_name = 'aaa'
user_A_password = 123456
bingo_captcha = 'qwer'

times = 1

print("***用户登陆系统***")
while times <= 5:
    #用户输入
    user_name = input("请输入用户名：")
    user_password = int(input("请输入密码："))
    user_captcha = input("请输入验证码：")
    print("\n***登陆中***\n")
    #判断验证码

    if user_captcha != bingo_captcha:
        print("验证码错误！\n*登陆失败*")

    else:
        print("验证码正确！")
        if user_name == user_A_name:
            print("用户名正确！")
            if user_password == user_A_password:
                print("密码正确！\n*****登陆成功*****")
                break
            else:
                print("密码错误！\n***登陆失败***")
        else:
            print("用户名错误！\n***登陆失败***")
    times += 1
else:
    print("\n===账号已锁定===")

3.2、容器类型——字符串

容器类型——字符串、列表、元组、字典 之 字符串

3.2.1、字符串简介

带引号（双引号和单引号都可以，甚至六个引号也行）的数据都是字符串，数据类型是 str

str1 = '''This
is
a
str'''
print(str1)
# 仅六个的支持换行

3.2.2、f-string 格式化字符串

语法：f"…{变量/表达式}…"

name = "fairy"
age = 20

print(f"My name is {name}, and I am {age} years old.")#更简洁
print("My name is %s, and I am %d years old." % (name, age))

3.2.3、字符串的输入

3.2.4、下标 和 切片

下标就是标号，也叫索引。计算机内存会为字符串中的每个字符从0开始分配下标。用于快速查找字符

# 语法：变量名[下标]

str1 = "fairy"

print(str1[0])		#f
print(str1[1])		#a
print(str1[2])		#i
print(str1[3])		#r
print(str1[4])		#y
print(str1[5])		#下标越界，错误

切片

作用：选取一部分数据

语法：变量名[开始位置下标**：结束位置下标：**步长] <左闭右开>

str2 = "0123456789"
print(str2[1:7:1])	# 输出 123456
print(str2[1:7])	# 输出 123456	默认步长为1
print(str2[1:7:2])	# 输出 135	
print(str2[2:])		#输出23456789	省略步长、结束，则从开始到结束

print(str2[:])		#全部输出
print(str2[::])		#全部输出

print(str2[::-1])	# 输出9876543210	倒序输出

print(str2[-1:3:-1])	# 输出 987654	注意区间的方向要和步长一致

3.2.5、字符串的常见操作

1）查找

1.1、find()

查找子串，成功返回第一个子串的首字符的下标；失败返回-1。

rfind() 从右往左查找

str1 = "This is a str"

print(str1.find("is"))			#2	返回下标

print(str1.find("is", 3, 12))	#5	可以指定范围

print(str1.rfind("is"))			#5 从右往左找

print(str1.find("an"))			#-1	找不到就返回-1

1.2、index()

查找子串，成功返回第一个子串的首字符的下标；失败报错。

rindex() 从右往左查找

str1 = "This is a str"

print(str1.index("a"))		#8 子串下标

print(str1.index("an"))		#无子串，报错

1.3、count()

返回字符串中子串的个数；如果没有返回0.

str1 = "This is a str"

print(str1.count("is"))	#2

print(str1.count("a"))	#1

print(str1.count("an"))	#0

1.4、len()

统计字符串的长度。

len(变量/数据)

str1 = "This is a str"

print(len(str1))	# 13

2）修改

2.1、replace() —— 替换

replace(旧子串, 新子串, 替换次数) 替换次数可以省略

str1 = "This is a str"

str2 = str1.replace("is", "are", 1)
str3 = str1.replace("is", "are")
str4 = str1.replace("is", "are", 10)

print(str2)
print(str3)
print(str4)

2.2、split() —— 分割

split(分割符号, 分割次数), 丢失分割符号 – 返回一个列表

str1 = "this is a str, and is a words"

print(str1.split(" "))
# 输出 ['this', 'is', 'a', 'str,', 'and', 'is', 'a', 'words']

2.3、join() —— 拼接

join()拼接: 把列表数据 和 连接符号 整体拼接成一个新的字符串

str1 = ['this', 'is', 'a', 'str,', 'and', 'is', 'a', 'words']

str2 = " ".join(str1)

print(str2)

# 输出 this is a str, and is a words

4、容器类型

4.1、容器类型——列表

4.1.1、列表语法

一个列表可以存储不同类型的数据，但是，一般存储相同的数据、方便维护。

name_list = ["fairy", "tale", "Mike", "continue"]#定义并初始化

print(name_list)#['fairy', 'tale', 'Mike', 'continue']
# 下标
print(name_list[0])#fairy
# 切片
print(name_list[0:3:1])#['fairy', 'tale', 'Mike']
# 逆置
print(name_list[::-1])#['continue', 'Mike', 'tale', 'fairy']

4.1.2、下标 & 切片

同字符串操作

4.1.3、列表的循环遍历

name_list = ["fairy", "tale", "Mike", "continue"]
# 推荐
for name in name_list:
    print(name)
# 不推荐
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

4.1.4、列表的常见操作

1）增加数据

变量名.函数名()

1.1、append()

作为整体、结尾追加

num_list = ["one", "two", "three"]

num_list.append("four")

print(num_list)
# 输出 ['one', 'two', 'three', 'four']

num_list = ["one", "two", "three"]

num_list.append(["four", "five"])

print(num_list)
# 输出['one', 'two', 'three', ['four', 'five']]

1.2、extend()

把容器类型数据拆开、然后在结尾依次追加

列表 --> 元素

字符串 --> 单个字符

num_list = ["one", "two", "three"]

num_list.extend("four")

print(num_list)
# 输出 ['one', 'two', 'three', 'f', 'o', 'u', 'r']

num_list = ["one", "two", "three"]

num_list.extend(["four", "five"])

print(num_list)
# 输出 ['one', 'two', 'three', 'four', 'five']
# 只拆开一层

1.3、insert()

在指定位置增加

name_list = ["one", "two", "three", "four"]

# 1、append()
name_list.append("five")
print(name_list)
# 输出 ['one', 'two', 'three', 'four', 'five']

# 2、extend()
name_list.extend("six")
print(name_list)
# 输出 ['one', 'two', 'three', 'four', 'five', 's', 'i', 'x']

# 3、insert()
name_list.insert(0, "zero")
print(name_list)
# 输出 ['zero', 'one', 'two', 'three', 'four', 'five', 's', 'i', 'x']

2）删除数据

2.1、del()

永久删除

没有返回值

del（目标） or del 目标

num_list = ["one", "two", "three"]

# 删除整个列表
del(num_list)		# 等价于 del num_list

print(num_list)		# 报错 NameError: name 'num_list' is not defined

num_list = ["one", "two", "three"]

# 删除列表的元素
del num_list[2]		# 等价于 del(num_list[2])

print(num_list)		# 输出 ['one', 'two']

num_list = ["zero", "one", "two", "three", "four", "five", "six"]

# 删除列表的一段元素——切片
del num_list[1:4]

print(num_list)		# 输出 ['zero', 'four', 'five', 'six']

2.2、pop()

删除，但是会返回该值，可用变量接收

pop（下标）：删除指定数据

pop（）：删除最后一个数据

num_list = ["zero", "one", "two", "three", "four", "five", "six"]

# 括号空着表示默认删除最后一个元素
num_list.pop()

print(num_list)
# 输出 ['zero', 'one', 'two', 'three', 'four', 'five']

num_list = ["zero", "one", "two", "three", "four", "five", "six"]

# 括号里填写下标、删除对应元素
num_list.pop(0)

print(num_list)
# 输出 ['one', 'two', 'three', 'four', 'five', 'six']

2.3、remove()

删除指定的数据

num_list = ["zero", "one", "two"]

# 删除指定元素
num_list.remove("one")		

print(num_list)
# 输出 ['zero', 'two']

2.4、clear()

清空

num_list = ["zero", "one", "two"]

# 清空列表
num_list.clear()

print(num_list)
# 输出 []		# 表示它还是个列表

3）修改数据

直接赋值

num_list = ["zero", "one", "two"]

num_list[0] = "ZERO"

print(num_list)
# 输出 ['ZERO', 'one', 'two']

4）查找数据

4.1、in / not in

判断某个数据是否存在，返回一个布尔类型数据

name_list = ["one", "two", "three", "four"]

print("one" in name_list)		#True
print("zero" in name_list)		#False

# 模拟用户注册时，取用户名的情景
name_list = ["张三", "李四", "王五"]

name = input("请输入用户名：")

if name in name_list:
    print("用户名重复，请重新输入")
else:
    print("用户名符合要求")

4.2、index()

查找某个数据，存在返回下标，不存在则报错

num_list = ["zero", "one", "two"]

print(num_list.index("zero"))		# 输出 zero 的下标 ：0
print(num_list.index("ZERO"))		# 报错 ValueError: 'ZERO' is not in list

4.3、count()

统计某个数据出现的次数

num_list = ["zero", "one", "two", "zero"]

print(num_list.count("zero"))		# 2
print(num_list.count("ZERO"))		# 0

4.4、len()

统计列表的数据个数

num_list = ["zero", "one", "two"]

print(len(num_list))			# 3

5）列表嵌套

list1 = [0, 1, 2, [33, 44], 5, [66, 77, [888, 999]], 10]

print(list1[2])				# 2
	
print(list1[3])				# [33, 44]
print(list1[3][1])			# 44

print(list1[5])				# [66, 77, [888, 999]]
print(list1[5][2])			# [888, 999]
print(list1[5][2][1])		# 999	 	

# 小案例 ： 随机分配办公室
# 导入随机数模块
import random
# 老师名字的列表
teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# 定义办公室列表，初始化为空
offices = [[], [], []]
# 循环随机分配
for i in teachers:
    #先生成一个随机数，代表办公室的编号
    num = random.randint(0, 2)
    #把当前的循环变量的值（老师的名字）增加到办公室中
    offices[num].append(i)
# 打印
print(offices)
# 打印每个办公室的老师
i = 1
for j in offices:
    print(f"{i}号办公室有{len(j)}名老师：",  end="")
    for k in j:
        print(k, end="、")
    print()
    i += 1

6）列表的排序和去重

6.1、排序

list1 = [2, 9, 4, 1, 2, 5, 7, 6, 3]
# 排序
list1.sort()	# 等价于 list1.sort(reverse=False)		即 默认升序
print(list1)	# 输出 [1, 2, 2, 3, 4, 5, 6, 7, 9]

list1 = [2, 9, 4, 1, 2, 5, 7, 6, 3]
# 排序 并修改参数
list1.sort(reverse=True)
print(list1)	# 输出 [9, 7, 6, 5, 4, 3, 2, 2, 1]

list1 = [2, 9, 4, 1, 2, 5, 7, 6, 3]
# 反转
list1.reverse()
print(list1)	# 输出 [3, 6, 7, 5, 2, 1, 4, 9, 2]

6.2、去重

list1 = [2, 9, 4, 1, 2, 5, 7, 6, 3]
print(type(list1))		# 输出 <class 'list'>
# 去重，但是原列表并没有改变，需要用新的变量接收返回值
list2 = set(list1)		
print(list1)			# 输出 [2, 9, 4, 1, 2, 5, 7, 6, 3] 原列表不变
print(type(list2))		# 输出 <class 'set'> 集合类型， 说明数据类型发生改变
print(list2)			# 输出 {1, 2, 3, 4, 5, 6, 7, 9}

print(list(list2))		# 输出 [1, 2, 3, 4, 5, 6, 7, 9]  说明可以强制转换

4.2、容器类型——元组 tuple

存储不可修改的数据，例如身份证号码、血型

但是，如果元组的元素有列表，那么列表里的元素可以修改

t1 = (1, 2, 3, [44, 55, 66])
print(type(t1))    		# 输出 <class 'tuple'>	即元组类型
# 尝试修改元组里的数据
t1[0] = 0       		# 报错 TypeError: 'tuple' object does not support item assignment

print(type(t1[3]))       #<class 'list'>		  即列表类型
# 尝试修改 元组里的 列表里的 数据
t1[3][2] = 666666		# 修改成功

print(t1)       		# 输出 (1, 2, 3, [44, 55, 666666])

4.2.1、元组语法

元组名（ , , , ）

t1 = (1, 2, 3, 4, 5)
print(type(t1))		#<class 'tuple'>
# 注意，元组只有一个元素也要加逗号
t2 = (1)
print(type(t2))		#<class 'int'>

t3 = (1,)
print(type(t3))		#<class 'tuple'>

4.2.2、元组的操作

1）查找

1.1、index()

t1 = (1, 2, 3, 2)

print(t1.index(3))	# 输出 2

1.2、count()

t1 = (1, 2, 3, 2, 3)

print(t1.count(3))	# 输出 2

1.3、len()

t1 = (1, 2, 3, 2, 3)

print(len(t1))		# 输出 5 

2）遍历

t1 = (1, 2, 3)

for i in t1:
    print(i)

5、容器类型 & 函数

5.1、容器类型——字典 dict

5.1.1、创建字典

name = {key:value, key:value, key:value······}

information = {'name': "fairy", 'age': 20, 'weight': 105.3}

print(information)
# 输出 {'name': 'fairy', 'age': 20, 'weight': 105.3}
print(type(information))
# 输出 <class 'dict'> 字典类型

print(information[0])
# 报错 KeyError: 0 	说明字典不支持下标访问

5.1.2、字典的常见操作

1）查找

# 按照指定的 key 查找数据

information = {'name': "fairy", 'age': 20, 'weight': 105.3}
print(information['name'])		# 输出 fairy

print(information['hobby'])		# 报错 KeyError: 'hobby'

# 用 get 查找

information = {'name': "fairy", 'age': 20, 'weight': 105.3}
print(information.get('name'))
print(information.get('age'))
print(information.get('name', '游客'))
# 如果字典里没有name这个key的话，他就输出‘游客’（而不是None）

2）修改 和 新增

# 语法相同
# 字典变量[key] = 值
# key存在 ？ 修改 ： 新增

# 修改
# 先按key查找到对应的数据，然后等号赋值
information = {'name': "fairy", 'age': 20, 'weight': 105.3}

information['age'] = 21
print(information)
# 输出 {'name': 'fairy', 'age': 21, 'weight': 105.3}
# 新增
information['QQ'] = 12346
print(information)
# 输出 {'name': 'fairy', 'age': 21, 'weight': 105.3, 'QQ': 12346}

3）删除

# del 删除字典
information = {'name': "fairy", 'age': 20, 'weight': 105.3}
del information
print(information) # 报错 NameError: name 'information' is not defined

# del 删除元素
information = {'name': "fairy", 'age': 20, 'weight': 105.3}
del information['weight']
print(information)	# 输出 {'name': 'fairy', 'age': 20}

# clear 清空字典
information = {'name': "fairy", 'age': 20, 'weight': 105.3}

information.clear()
print(information)		# 输出 {}

4）查找 plus

4.1、len()

information = {'name': "fairy", 'age': 20, 'weight': 105.3}

print(len(information))		# 输出 3

4.2、keys()

查找字典中所有的key、返回一个序列

information = {'name': "fairy", 'age': 20, 'weight': 105.3}

print(information.keys())
# 输出 dict_keys(['name', 'age', 'weight'])
# 这是序列、不是列表（省内存）

for key in information.keys():
    print(key)

4.3、values()

查找字典中所有的value、返回一个序列

information = {'name': "fairy", 'age': 20, 'weight': 105.3}

print(information.values())
# 输出 dict_values(['fairy', 20, 105.3])

for value in information.values():
    print(value)

4.4、items()

查找字典中所有的键值对、返回一个序列

information = {'name': "fairy", 'age': 20, 'weight': 105.3}

print(information.items())
# 输出 dict_items([('name', 'fairy'), ('age', 20), ('weight', 105.3)])
# 键值对以元组的形式输出

for item in information.items():
    print(item)
'''
('name', 'fairy')
('age', 20)
('weight', 105.3)
'''
# 知道item的数据是一个元组，这个元组包含2个部分数据（key、value），可以用2个变量接收————这就是所谓的拆包    
for key, value in information.items():
    print(key, end='\t')
    print(value)
'''
name	fairy
age	20
weight	105.3
'''    

5.2、公共方法

所有容器类型通用的操作

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

str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)		# 输出 aabb

5.3、函数

作用：封装、减少重复代码

5.3.1、函数定义 & 调用

'''
# 函数定义
def 函数名(参数，可有可无)
	函数体

# 函数调用
函数名（）
'''
# 定义
def my_sum(a, b):
    print("函数体")
    print("sum is %d" % (a + b))

# 调用
my_sum(3, 5)

5.3.2、函数的文档说明

也叫说明文档

可以通过 help(函数名) 的形式查看函数内容

定义函数的文档说明：在函数体的第一行用六个引号括起来

help(print)

'''
输出：
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

'''

# 自定义函数
def my_sum(a, b):
    """
    这是自定义函数的文档说明
    作用：求两个数的和
    :param a: 加数 1
    :param b: 加数 2
    :return: a 与 b 的和
    """
    print("sum is %d" % (a + b))
# 调用函数
my_sum(3, 5)
# 函数的文档说明
help(my_sum)
'''
输出：
Help on function my_sum in module __main__:

my_sum(a, b)
    这是自定义函数的说明文档
    作用：求两个数的和
    :param a: 加数 1
    :param b: 加数 2
    :return: a 与 b 的和
'''

5.3.3、函数的参数

形参 & 实参

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

5.3.4、函数的返回值

return 关键字

函数遇到return就结束

5.3.5、函数的嵌套调用

def test1():
    print("========= 1 =========")
    print("函数一")
    print("========= 1 =========")


def test2():
    print("========== 2 ==========")
    test1()
    print("========== 2 ==========")


test2()
'''输出：
========== 2 ==========
========= 1 =========
函数一
========= 1 =========
========== 2 ==========
'''

6、函数

6.1、函数的嵌套

# 打印一行的函数
def print_line():
    print("-"*20)

# 打印num行的函数
def print_many(num):
    for i in range(0, num, 1):
        print_line()

# 输出5行
print_many(5)

# 自定义求和函数
def num_sum(a, b, c):
    return a + b + c


# 自定义求平均值函数
def num_ave(x, y, z):
    return num_sum(x, y, z) / 3


# 调用函数
print(num_ave(1, 2, 3))

6.1、变量的作用域

6.1.1、局部变量

函数体内部的变量

函数内部即可读也可写、外部不可访问

6.1.2、全局变量

在函数内外都能生效的变量

b = 10				# 全局变量


def test():			# 测试函数
    print(b)		# 试图访问全局变量


test()			   # 调用测试函数，正常

b = 10				# 全局变量


def test():			# 测试函数
    print(b)		# 试图访问全局变量
	b = 100		    # 试图修改全局变量

test()			   # 调用测试函数，异常
'''
Traceback (most recent call last):
  File "E:/Users/fairy/Documents/project/python/hm/day 06/code 001.py", line 33, in <module>
    test()
  File "E:/Users/fairy/Documents/project/python/hm/day 06/code 001.py", line 29, in test
    print(b)
UnboundLocalError: local variable 'b' referenced before assignment
'''
# 正确的操作：
b = 10				# 全局变量


def test():			# 测试函数
    global b		# 声明，告诉解释器b是全局变量
    print(b)		# 试图访问全局变量
    b = 100			# 试图修改全局变量


test()				# 调用测试函数，正常
print(b)			# 全局变量以被修改

6.2、多函数执行流程

• 全局变量因为在函数内外都生效, 随着函数内外对全局变量数据的修改, 全局变量的结果会发生变化

• 函数的返回值可以作为其他函数的参数传入

6.3、函数的返回值

打印函数调用其实打印的是函数的返回值, 如果函数有返回值, 直接打印返回值结果;如果没有返回值, 打印None(无)

2. 返回多个值写法:
   a) return 数据1, 数据2, 数据3… – 返回的是元组
   b) return 元组
   c) return 列表
   d) return 字典

6.4、参数

6.4.1、位置参数

形参和实参的个数必须一致, 否则报错: 丢失位置参数

def test(a, b, c):
    return a * b + c


print(test(1, 2))
'''
Traceback (most recent call last):
  File "E:/Users/fairy/Documents/project/python/hm/day 06/code 001.py", line 74, in <module>
    print(test(1, 2))
TypeError: test() missing 1 required positional argument: 'c'
'''

形参和实参的顺序需要一一对应, 如果不对应, 导致数据无意义, 但不报错

def test(a, b, c):
    return a * b + c


print(test(1, 2, 3))		# 5

6.4.2、关键字参数

def test1(name, age):
    print(name)
    print(age)


test1(age=20, name="fairy")		# 输出 fairy \n 20
test1(20, name="fairy")		# 报错 TypeError: test1() got multiple values for argument 'name'
test1(name="fairy", 20)		# 报错 SyntaxError: positional argument follows keyword argument

6.4.3、缺省参数

• 就是默认参数. 带有默认值的参数 : key = value
• 如果缺省参数不传递数据, 使用默认值;如果传递了真实数据, 修改对应的默认值

def test1(name, age, gender="男"):
    print(name)
    print(age)
    print(gender)


test1("fairy", 20)				# 输出 fairy 20 男
test1(name="fairy", age=20)		 # 输出 fairy 20 男
test1("fairy", 20, "女")			# 输出 fairy 20 女

6.4.4、不定长位置参数

• 不定长位置参数写法 *args, 用来接收不知道用户输入数据个数的时候使用, 返回一个元组, 这个过程就是组包过程
• 所谓的不定个数, 指的是任意多个, 包含0个

# 语法 *变量名
# 习惯取变量名为 args
# 返回一个元组，称之为 组包
def into_print(*args):
    print(args)	


into_print()			# ()
into_print(123)			# (123,)
into_print(1, 2, 3)		# (1,2,3)

6.4.5、不定长关键字参数

也叫不定长字典参数, 用来接收不限定个数的关键字参数, 返回一个字典, 写法 **kwargs

# 也叫不定长字典参数，用来接收不限定个数的关键字参数
def info_print(**kwargs):
    print(kwargs)


info_print(name="Fairy", weight=105.4, gender="男")
# 输出 {'name': 'Fairy', 'weight': 105.4, 'gender': '男'}

6.4.6、参数混用

位置参数：最前面

不定长位置参数：一定在位置参数后面

关键字参数、缺省参数：在不定长关键字参数之前

不定长关键字参数：最后面

6.5、拆包

• 元组和列表: 列表和元组内的数据的个数, 用等量的变量数接收, 这个变量就是元组或列表内的数据

  list1 = [1, 2, 3]
  x, y, z = list1
  

• 字典拆包: 字典的键值对个数和拆包的变量个数相等, 此时变量指的是字典的key, 如果想得到value, 按key查找 字典变量[key]

  dict1 = {"name": "Python", "age": 30}
  a, b = dict1
  print(dict1[a])
  

# 元组
def test1():
    return 10, 20, 30


result = test1()
print(result)

a, b, c = result
print(a)
print(b)
print(c)

# 列表


# 字典

​

7、引用 & 学员管理系统

7.1、引用

a = 10
b = 20

# 值不同 -->  地址不同
print(id(a))		# 输出 140709313779648
print(id(b))		# 输出 140709313779968

# 修改 b 的值
b = 10

# 值相同 -->  地址相同
print(id(a))		# 输出 140709313779648
print(id(b))		# 输出 140709313779648

结论：python的数据传递方式为：引用传递

7.2、交换两个变量的方法

1）三杯水

a = 10
b = 20

temp = a
a = b
b = temp

2）求和

a = 10
b = 20

a = a + b    # a=30 b=20
b = a - b    # a=30 b=10
a = a - b    # a=20 b=10

3）MOST EASY

a = 10
b = 20

a, b = b, a

7.3、可变与不可变类型

• 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
• 可变类型有： 列表、字典、集合
• 不可变类型有： 数字、字符串、元组

7.4、学员管理系统

功能概要：

• 增加学生信息
• 删除学生信息
• 查找学生信息
• 修改学生信息
• 显示全部
• 退出系统

student_list = []


# 开始界面提示信息
def star_interface():
    print("------欢迎登陆用户管理系统-----")
    print(" 1、增加学员信息")
    print(" 2、删除学员信息")
    print(" 3、查找学员信息")
    print(" 4、修改学员信息")
    print(" 5、显示全部学员")
    print(" 6、退出系统")


# 增加学员信息
def add_stu():
    global student_list
    # 输入信息
    new_name = input("请输入姓名：")
    new_id = input("请输入学号：")
    new_tel = input("请输入电话：")
    # 判断信息是否正确
    for i in student_list:
        # 学号重复
        if new_id == i["id"]:
            print("输入错误：学号重复！")
            return
    # 信息无误，保存为一个字典
    new_stu = {"name": new_name, "id": new_id, "tel": new_tel}
    # 把字典增加到学生列表
    student_list.append(new_stu)
    print("-----录入成功！-----姓名：%s、 学号：%s、 电话号码：%s" % (new_name, new_id, new_tel))


# 删除学生信息
def del_stu():
    global student_list
    while True:
        # 输入信息
        del_id = input("请输入欲删除学生的学号：")
        # 遍历
        for i in student_list:
            if del_id == i["id"]:
                # print(i)
                print("姓名：%s、 学号：%s、 电话号码：%s" % (i["name"], i["id"], i["tel"]), end="  -->  ")
                del_flag = int(input("确认删除请按 1 、否则输入 0："))
                if del_flag == 1:
                    student_list.remove(i)
                    print("该学生信息已成功删除！")
                    return
                elif del_flag == 0:
                    print("操作已取消")
                    return
        else:
            print("未查找到该学号、请检查输入的学号是否正确")


# 查找学生信息
def find_stu():
    while True:
        # 输入信息
        find_id = input("请输入欲查找的学生的学号：")
        # 遍历列表查找
        for i in student_list:
            # 查找成功
            if find_id == i["id"]:
                print("查找成功： 姓名：%s、 学号：%s、 电话号码：%s" % (i["name"], i["id"], i["tel"]))
                return
        else:
            print("未查找到该学号、请检查输入的学号是否正确")


# 修改学生信息
def modify_stu():
    global student_list
    while True:
        # 输入信息
        modify_id = input("请输入欲修改的学生的学号：")
        # 遍历列表
        for i in student_list:
            # 查找到学生信息
            if modify_id == i["id"]:
                print("欲修改对象：姓名：%s、 学号：%s、 电话号码：%s" % (i["name"], i["id"], i["tel"]))
                i["name"] = input("修改后的姓名：")
                i["tel"] = input("修改后的电话：")
                print("修改成功！\n修改后信息：姓名：%s、 学号：%s、 电话号码：%s" % (i["name"], i["id"], i["tel"]))
                return
        else:
            print("未查找到该学号、请检查输入的学号是否正确")


# 显示全部学生信息
def all_stu():
    tplt = "{0:{3}^10}\t{1:{3}^10}\t{2:^10}"
    print(tplt.format("姓名", "学号", "电话号码", chr(12288)))

    for i in student_list:
        print(tplt.format(i["name"], i["id"], i["tel"], chr(12288)))
        
        
# 主程序
star_interface()
while True:
    print("\ntips：1-增  2-删 3-查 4-改 5-全 6-退")
    num = int(input("输入对应数字进入相应功能:"))

    if num == 1:
        # print("增")
        add_stu()
    elif num == 2:
        # print("删")
        del_stu()
    elif num == 3:
        # print("查")
        find_stu()
    elif num == 4:
        # print("改")
        modify_stu()
    elif num == 5:
        # print("全")
        all_stu()
    elif num == 6:
        # print("退")
        break
    else:
        print("输入有误、重新输入")
print("-----程序已退出-----")

8、递归* & 文件 &

8.1、递归

自我调用

# 递归求 1 到 num 之间的数字的累加和
def my_sum(num):
    # if 为递归结束的条件判断
    if num == 1:	
        return 1
    # 返回 num 和 调用自身的返回值	
    return num + my_sum(num - 1)

print(my_sum(100))

• python 系统内置的递归最大深度为 996

• 可以导入 sys 模块 的 get······() 函数查看

  import sys
  print(sys.getrecursionlimit())		# 1000
  

8.2、*匿名函数

• 就是没有名字的函数
• 作用：封装及其简单的代码（只有一行、直接返回、调用一个函数）
• 也叫lambda表达式
• 语法：lambda 参数列表：代码

# 定义一个匿名函数
lambda: 100
# lambda: 100 函数名
# (lambda: 100) 加括号提高优先级
# (lambda: 100)() 再加括号视为调用函数
print((lambda: 100)())	# 输出100
# 但是这样括号太多关系混乱，一般按如下操作
f1 = lambda: 100
# 把匿名函数赋值给（或者说是引用）一个变量
print(f1())
# 调用函数

1）没有参数

f2 = lambda: "hello world"
print(f2()
# 输出 hello world

2）一个参数

f3 = lambda num: (1 + num) * num / 2
print(f3(100))
# 输出 5050.0

3）多个参数

f4 = lambda a, b: a ** b
print(f4(3, 2))
# 输出 9

4）不定参数

# 1 不定位置参数
f5 = lambda *args : print(args)
f5(1, 2, 3, "fairy")
# 输出 (1, 2, 3, 'fairy')

# 2 不定关键字参数
f6 = lambda **kwargs: print(kwargs)
f6(name="fairy", age=20, weight=105.3)
# 输出 {'name': 'fairy', 'age': 20, 'weight': 105.3}

8.3、*推导式——列表 & 字典

• 快速创建一个有规律的列表/字典、控制有规律的列表/字典
• 内层用到的关键代码是 for
• 语法：[ 返回数据 for 循环代码 ]

8.3.1、列表推导式

# 需求： 生成一个1~10的列表：[1,2,3,4,5,6,7,8,9,10]

# way 1 -- while循环
list1 = []
i = 1
while i <= 10:
    list1.append(i)
    i += 1
print(list1)

# way 2 -- for循环
list2 = []
for i in range(1,11):
    list2.append(i)
print(list2)

# way 3 -- 列表推导式
list3 = [i for i in range(1,11)]
print(list3)

# 带 if 的推导式
list4 = [i for i in range(0, 11) if i % 2 == 0]
print(list4)
# 输出 [0, 2, 4, 6, 8, 10]

# 带 循环的推导式
# 目标 [(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2)]

#  way 1 -- 嵌套循环
list5 = []
for i in range(0, 3):
    for j in range(1, 3):
        tuple1 = (i, j)
        list5.append(tuple1)
print(list5)

# way 2 -- 推导式
list6 = [(i, j) for i in range(0, 3) for j in range(1, 3)]
print(list6)

8.3.2、字典推导式

快速创建有规律的字典–合并2个列表为字典

# 初体验
dict1 = {i: i**2 for i in range(1, 6)}
print(dict1)
# 输出 {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 列表合并为字典

list1 = ['name', 'age', 'weight']
list2 = ['fairy', 20, 105.9]

dict2 = {list1[i]: list2[2] for i in range(len(list1))}
print(dict2)

# 输出 {'name': 105.9, 'age': 105.9, 'weight': 105.9}

# 提取字典中符合要求的键值对

dict3 = {'apple': 10, 'banana': 8, 'pear': 6, 'group': 12}
# 筛选价格大于等于10的
dict4 = {key:value for key, value in dict3.items() if value >= 10}
print(dict4)
# 输出 {'apple': 10, 'group': 12}

8.4、文件操作基础

# 文件初体验
# 问：在一个 *.txt 文件中写入“Hello world,this is a file. ”该怎么操作？

# 第一步 打开（或者创建）一个 *.txt 文件
f = open('1.txt', 'w', encoding='utf-8')
# w -- 表示写入write(r表示读取read)
# encoding="utf-8" -- 设置字符编码: utf-8,万国码 -- 如果打开的文件内容有中文(windows必须加)
# 如果文件不存在那么就会创建，如果存在那么就先清空，然后写入数据

# 第二步 往文件里写入数据
f.write("Hello world,this is a file. ")

# 第三步 关闭该文件
f.close()

1、文件打开

语法 ： open(“目标文件”, “打开方式/访问模式”, encoding= “utf-8”)

1. 目标文件：可以是当前么路的一个文件、也可以是其他目录的文件
2. 访问模式：就是打开文件的目的；w/r/a: Write-写入 Read–读取 Append–追加 ；省略不写的话默认为read
   • w – 文件不存在就会创建一个 – 覆盖写入（全给删了在写）
   • r – 文件不存在就会报错
   • a – 文件不存在也会创建一个 – 追加写入（在后面接着写）
3. 字符编码：encoding=“utf-8” – 设置字符编码（utf-8,万国码）

2、写入数据

如果向文件里写入数据, 数据类型必须是str

# 以 写入 模式打开（或者是创建）一个文件
f = open('1.txt', 'w', encoding='utf-8')
# 往文件里写入字符串
f.write("Hello world,this is a file. ")
# 关闭文件
f.close()

# 效果 ： 目录下创建了 1.txt 文件，并写入了目标字符串

# 以 w 打开的文件可以写入数据，那可以读取数据嘛？

f = open('1.txt', 'w', encoding='utf-8')
f.write("Hello world,this is a file. ")
# 尝试读取数据并打印出来
con = f.read()
print(con)

f.close()

''' 报错
Traceback (most recent call last):
  File "E:/Users/fairy/Documents/project/python/hm/day 08/code 02.py", line 6, in <module>
    con = f.read()
io.UnsupportedOperation: not readable
'''

# 结论 ：以 w/a 形式打开的文件只能写不能读

3、读取数据

# 读取数据初体验

# 第一步 打开文件
f = open('1.txt', 'r', encoding='utf-8')
# 可以简写为 f = open("1.txt")  # 省略不写默认以 r 打开文件
# 如果目标文件不存在，程序将会报错

# 第二步 用一个变量接收读取的数据、并打印
con = f.read()
print(con)

# 第三步 关闭文件
f.close()

3.1、read

# 使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
f = open('1.txt', 'r', encoding='utf-8')

con = f.read(1)		# 只读了一个字节

print(con)

f.close()

3.2、readlines

f = open('1.txt', 'r', encoding='utf-8')
# 读取第一行数据
con = f.readline()
print(con)
# 继续读取 下一行 的数据
con = f.readline()
print(con)

f.close()

3.3、readlines

f = open('1.txt', 'r', encoding='utf-8')

con = f.readlines()
print(type(con))		# <class 'list'>

i = 1
for temp in con:
    print("%d：%s" % (i, temp), end='')	# 因为读取的数据有换行
	i += 1
f.close()
''' 输出
<class 'list'>
1：When you are old and grey and full of sleep, 当你老了，头发花白，睡意沉沉，
2：And nodding by the fire，take down this book, 倦坐在炉边，取下这本书来，
3：And slowly read,and dream of the soft look 慢慢读着，追梦当年的眼神
4：Your eyes had once,and of their shadows deep; 你那柔美的神采与深幽的晕影。
5：How many loved your moments of glad grace, 多少人爱过你昙花一现的身影，
6：And loved your beauty with love false or true, 爱过你的美貌，以虚伪或真情，
7：But one man loved the pilgrim Soul in you 惟独一人曾爱你那朝圣者的心，
8：And loved the sorrows of your changing face; 爱你哀戚的脸上岁月的留痕。
9：And bending down beside the glowing bars, 在炉罩边低眉弯腰，
10：Murmur,a little sadly,how Love fled 忧戚沉思，喃喃而语，
11：And paced upon the mountains overhead 爱情是怎样逝去，又怎样步上群山，
12：And hid his face amid a crowd of stars. 怎样在繁星之间藏住了脸。
'''

4、访问模式

# w/r/a 仅支持读或写
# w+/r+/a+ 可读可写

f = open('1.txt', 'r+', encoding='utf-8')
# 读取一行
con = f.readline()
print(con)
# 文件指针回到文档首
f.seek(0)
# 覆盖写入一个字符串（把原来的字符换成写入的，后面的不变）
f.write("Hello python")
# 关闭文件
f.close()

9、文件 & 二进制打开

9.1、文件备份

old_file = input("输入文件名（需要后缀）：")

print("开始备份！")
num = old_file.rfind(".")

# 得到备份文件的名字
new_file = old_file[:num:] + "--备份" + old_file[num::]

f_old = open(old_file, 'rb')
f_new = open(new_file, 'wb')

# f_new.write("备份文件\n")
while True:
    con = f_old.read(1024)
    if len(con) == 0:
        print("读取完毕！")
        break
    f_new.write(con)

# 关闭顺序 --> 先打开的后关闭
f_new.close()
f_old.close()

print("备份成功")

9.2、文件和文件夹操作

Python操作文件或文件夹要借助os模块, import os
 rename(旧名字, 新名字) – 重命名文件或文件夹
 remove(文件名) – 删除指定文件
 mkdir(文件夹名字) – 创建文件夹
 rmdir(目标文件夹名字) – 删除文件夹
 getcwd() – 获取当前目录路径
 listdir(空或目录路径) – 获取某个目录列表(获取某个目录内所有文件名, 返回一个列表)
 chdir(目录路径) – 改变目录路径

10、补充

1、sort 三个数排序 if 嵌套if

def sort_new(x, y, z):
    if x > y:
        x, y = y, x
    if y > z:
        y, z = z, y
    if x > y:
        x, y = y, x
    return x, y, z