Python（上）

Python

下载：Welcome to Python.org

• step1:勾选（Add Python 3.10 to PATH）

• step2:点击Customize installation（自定义安装）

• step3:选择安装路径

• step4:close

• step5:验证（cmd>>python）

Python开发工具——PyCharm

网站：PyCharm：JetBrains为专业开发者提供的Python IDE

注释

单行注释：#（快捷键——Ctrl+/）

多行注释：三个双引号“”“ ”“”

---

一、数据类型

类型	描述	实例	说明
	整数（int）	1234
数字 （Number）	浮点数（float）	3.14，1.3e5
	复数（complex）	3+4i
布尔型	bool	True、False
字符串（String）	描述文本的一种数据类型不可变	‘hello world’ "hello word" "'hello word'"	1.字符串可以用‘+’连接起来，也可用‘*’重复； 2.字符串有两种索引方式：1）从左往右0开始，2）从右往左-1开始 3.反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
列表（List）	有序的可变序列	[1,2,3] ['a','b'],['c',2]	1.List 可以被索引和切片。 2.List 可以使用 + 操作符进行拼接。
元组（Tuple）	有序的不可变序列	(2，-5，6） (3，）	1.如果元组中只有一个元素的话，后面的逗号不能省略 2.元组也可以被索引和切片 3.元组也可以使用 + 操作符进行拼接。
集合（Set）	无序不重复可变集合	{'a','b','c'}	1.创建一个空集合： set() 2.不支持下标索引
字典（Dictionary）	无序Key-Value不重复可变集合	{1:‘food’,2:'taste',3:'import'}	1.元素形式为：“键：值” 2.字典的关键字必须为不可变类型 3.创建一个空字典：{ } 4.不支持下标索引

type()函数
#方式一
print(type("黑马程序员"))
print(type(3.4))
#方式二
string_type=type("黑马程序员")
print(string_type)
#方式三
money=50
money_type=type(money)
print(money_type)
注：变量没有类型，变量存储的数据是有类型的。

1.数字

1.1数字函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回10
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 10
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

1.2随机数函数

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

1.3三角函数

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

1.4数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

2.序列

序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

是否支持下标索引

• 支持：列表、元组、字符串——序列类型

• 不支持：集合、字典——非序列类型（不能用while遍历）

是否支持重复元素

• 支持：列表、元组、字符串

• 不支持：集合、字典

是否可以修改

• 支持：列表、集合、字典

• 不支持：元组、字符串

2.1序列索引

• 正索引（左——右）

• 负索引（右——左）

2.2序列切片

语法：序列[起始下标：结束下标：步长]

（表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列）

1）起始下标表示从何处开始，可以留空，留空视作从头开始

2）结束下标表示何处结束，可以留空，留空视作截取到结尾

3）步长表示，依次取元素的间隔

步长1表示，一个个取元素

步长为负数表示，反向取（注意：起始下标和结束下标也要反向标记）

（进行切片操作不会影响序列本身，原因是元组、字符串不允许修改）

#对list进行切片，从1开始，4结束，步长1[1,2,3]
list_01=[0,1,2,3,4,5,6]
result1=list_01[1:4]
print(f"结果1:{result1}")
​
#对tuple进行切片，从头开始，到最后结束，步长1(0, 1, 2, 3, 4, 5, 6)
tuple_01=(0,1,2,3,4,5,6)
result2=tuple_01[:]
print(f"结果2：{result2}")
​
#对str进行切片，从头到尾，步长-1:543210->432
str_01="012345"
result3=str_01[::-1][1:3]
print(f"结果3：{result3}")

2.3序列相加+

拼接

2.4序列相乘*

重复

2.5检查元素是否包含在序列中

str="W3Cschool"
print('C'in str)

2.6和序列相关的内置函数

函数（方法）	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

3.字符串

• 单引号定义法：name='Python'

• 双引号定义法：name="Python"

• 三引号定义法：name="""Python"""

3.1字符串的拼接

字符串字面量之间的拼接

print("好好学习"+"天天向上")

字符串字面量和字符串变量的拼接

name1="好好学习"
name2="天天向上"
print(name1+name2)

3.2字符串格式化

eg1：
name1="好好学习"
name2="天天向上%s" % name1
print(name2)
​
eg2：
class_num=57
avg_salary=16781
message="Python大数据学科，北京%s期，毕业平均工资：%s" % (class_num,avg_salary)
print(message)
​
其中%s
- %表示：我要占位
- s表示：将变量变成字符串放入占位的地方

格式符号	转化
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点型，放入占位位置

精度控制

m.n（%5.2f）

• m：控制宽度，要求是数字（设置的宽度小于数字自身，不生效）

• n：控制小数点精度，要求是数字（四舍五入）

3.3字符串格式化——快速写法

name="Tom"
set_up_year=1997
stock_price=32
print(f"我是{name},我出生于：{set_up_year},我今天的花费为:{stock_price}")

3.4字符串格式化——表达式的格式化

print("1*1的结果是：%d" % (1*1)
print(f"1*1的结果是：{1*1}")
print("字符串在Python中的类型是：%s" % type('字符串'))

3.5Python 的字符串内建常用函数

函数（方法）	描述
capitalize()	将字符串的第一个字符转换为大写
count(str, beg= 0,end=len(string))	返回str在string里面出现的次数，如果指定beg或者end，则返回指定范围内str出现的次数
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常
len(string)	返回字符串长度
lower()	转换字符串中所有大写字符为小写
split(str="，", num=string.count(str))	以“，”为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串，并存放入列表中。语法：字符串.split(分隔符字符串)（注意：字符串本身不变，而是得到了一个列表对象）
strip()	字符串的规整操作，去前后空格以及回车。语法：字符串.strip()

my_str="hello word"
my_str_list=my_str.split(" ")
print(f"字符串：{my_str},将字符串分隔后得到：{my_str_list},类型：{type(my_str_list)}")
#字符串：hello word,将字符串分隔后得到：['hello', 'word'],类型：<class 'list'>
my_str="   hello word "
print(my_str.strip())
​
#去前后指定字符串
#语法：字符串.strip(字符串)(只能从前往后按顺序去掉)
my_str="hello word "
my_str_new=my_str.strip("h")
print(my_str_new)
my_str="hello word21   "
count=my_str.count("o")
print(count)
my_str="hello word21   "
print(len(my_str))

3.6字符串进行遍历

方式一：
my_str="hello word21   "
for i in my_str:
    print(i)
​
方式二：
my_str="hello word21   "
index=0
while index<len(my_str):
    print(my_str[index])
    index=index+1

4.list(列表)

4.1列表的定义

列表使用小括号”[ ]“，且使用逗号”，“隔开各个数据，数据可以是不同的数据类型。

#字面量
[元素1，元素2，元素3，元素4，...]
​
#定义变量
变量名称=[元素1，元素2，元素3，元素4，...]
​
#定义空列表
变量名称=[]
变量名称=list()

4.2列表的下标（索引）

列表[下标索引]

0、1、2、...
反向-1、-2、-3、...
​
name_list=['Tom','Lily','Rose']
print(name_list[0]) #Tom
​
name_list1[[1,2,3],[4,5,6]]
print(name_list[1][0]) #4

4.3嵌套列表

a = ['a', 'b', 'c'] 
n = [1, 2, 3] 
x = [a, n] 
x [['a', 'b', 'c'], [1, 2, 3]] 
x[0] ['a', 'b', 'c'] 
x[0][1] 'b'

4.4列表的常用操作

操作	函数（方法）	说明
查找元素下标	index（元素）	查找某元素的下标（语法：列表名.index（元素））
插入元素	append(x)	将元素x添加至列表尾部（语法：列表名.append(7)）
	使用+运算符	aList=[3,4,5]，aList=aList+[7]
	extend(iterable)	将可迭代对象iterable中所有元素添加至列表尾部（语法：列表名.extend（[7,8,9]））
	insert(index,x)	在列表指定位置index处添加元素x（语法：列表名.insert(index,x)）
删除元素	del aList[1]
	remove(x)	在列表中删除首次出现的指定元素x（语法：列表名.remove(x)）
	pop([index])	删除并返回列表对象指定位置的元素，默认最后一个元素（语法：列表名.pop()）
清空列表	clear()	删除列表中所有元素，但保留列表对象
修改元素		aList=[3,4,5]，aList[0]=1 (#[1,4,5])
统计元素个数	count(x)	返回指定元素x在列表中的出现次数（语法：列表名.count(x)）
	reverse(x)	对列表元素进行原地翻转
	sort(key=None,reverse=False)	对列表元素进行原地排序
	copy()	返回列表对象的浅复制

#删除
方法一：
x=[1,2,1,2,3,1,1,1]
for i in x[::]:
    if i==1:
        x.remove(i)
print(x)
​
方法二（从后往前删除）：
for i in range(len(x)-1,-1,-1):
    if x[i]==1:
        del x[i]
print(x)

5.tuple(元组)

5.1定义元组

元组使用小括号”（）“，且使用逗号”，“隔开各个数据，数据可以是不同的数据类型。

#定义元组字面量
（元素，元素，......，元素）
（元素，）#单个元素的元组最后要写逗号
#定义元组变量
变量名=（元素，元素，......，元素）
#定义空元组
变量名称=（）     #方式一
变量名称=tuple()  #方式二
#元组的嵌套
（（元素，元素），（））
#下标索引取出内容（同列表）

5.2元组内置函数

operator(tuple1,tuple2) 较两个元组元素

import operator
dict1 = (1, 2, 3) 
dict2 = ('a', 'b', 'c')  
operator.eq(dict1, dict2) 
>>>False
#index()、count()、len(元组)
t=(1,2,3,4,1)
index=t.index(1) #0
num=t.count(1) #2
num=len(t) #5
注：不可以修改（增加或删除元素等）

6.set(集合)

集合：无序可变的容器对象，与字典一样使用一对大括号作为界定符，同一个集合的元素之间不允许重复，集合中每个元素都是唯一的。

6.1集合的定义

基本语法
#定义集合字面量
{元素，元素，......，元素}
#定义集合变量
变量名称={元素，元素，......，元素}
#定义空集合
变量名称=set()

6.2添加新元素

语法：集合.add(元素)——将指定元素添加到集合内

my_set={1,2,2,3}
print(my_set)
my_set.add(4)
print(my_set)

语法：集合.update(x)——参数可以是列表，元组，字典等

thisset = set(("Google", "w3Cschool", "Taobao"))
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])  
print(thisset)

6.3移除元素

my_set={1,2,2,3}
my_set.remove(2)
print(my_set)

6.4从集合中随机取出元素

语法：集合.pop()（功能：从集合中随机取出一个元素）

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

my_set={1,2,2,3}
element=my_set.pop()
print(element)

6.5清空集合

语法：集合.clear()（功能：清空集合）

结果：结合本身被清空

my_set={1,2,2,3}
print(my_set.clear())

6.6取出两个集合的差集

语法：集合1.difference(集合2)（功能：取出集合1和集合2的差集（集合1有而集合2没有的元素））

结果：得到一个新集合，集合1和集合2不变

set1={1,2,3,4}
set2={3,4,8,9}
set3=set1.difference(set2)
print(set3) #{1, 2}
print(set1) #{1，2，3，4}不变
print(set2) #{3，4，8，9}不变

6.7消除两个集合的差集

语法：集合1.difference_update(集合2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

结果：集合1被修改，集合2不变

set1={1,2,3,4}
set2={3,4,8,9}
set1.difference_update(set2)
print(set1) #{1, 2}
print(set2) #{8, 9, 3, 4}

6.8两个集合合并

语法：集合1.unior(集合2)

功能：将集合1和集合2组合成新集合

结果：得到新集合，集合1和集合2不变

set1={1,2,3,4}
set2={3,4,8,9}
set3=set1.union(set2)
print(set3)
print(set1)
print(set2)
# {1, 2, 3, 4, 8, 9}
# {1, 2, 3, 4}
# {8, 9, 3, 4}

6.9统计元素个数

语法：len(集合)

set1={1,2,3,4}
num=len(set1)
print(num) #4

6.10集合的遍历

set1={1,2,3,4}
for i in set1:
    print(i)
list1=[1,2,3,4,5]
set1=set()
for i in list1:
    print(i)
    set1.add(i)
print(set1)

6.11集合内置方法完整列表

函数（方法）	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
issubset()	判断指定集合是否为该方法参数集合的子集
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
union()	返回两个集合的并集
update()	给集合添加元素

7.dict(字典)

7.1字典的定义

使用{}，存储的元素是一个个的：键值对。(不允许key重复，新的会覆盖老的)

#定义字典字面量
{key:value,key:value,......,key:value}
#定义字典变量
my_dict={key:value,key:value,......,key:value}
#定义空字典
my_dict={} #方式一
my_dict=dict() #方式二
​
dict1={"张三":23,"李四":34,"赵五":21}
dict2={}
dict3=dict()
print(dict1)
print(dict2)
print(dict3)
#通过key来取对应的value
dict1={"张三":23,"李四":34,"赵五":21}
age=dict1["李四"]
print(age)

7.2字典的嵌套

dict2={
    "王力鸿":{
        "语文":77,"数学":66,"英语":33
    },
    "周杰伦":{
        "语文":97,"数学":76,"英语":93
    }
}
print(dict2)
print(dict2["周杰伦"]["语文"])

7.3新增元素

语法：字典[key]=Value

结果：字典被修改，新增了元素

dict1={"张三":23,"李四":34,"赵五":21}
dict1["小六"]=33
print(dict1)

7.4更新元素

语法：字典[key]=Value

结果：字典被修改，元素被更新

（注：字典key不可以重复，所以对已存在的key执行上述操作，就是更新Value值）

dict1={"张三":23,"李四":34,"赵五":21}
dict1["张三"]=44
print(dict1)

7.5删除元素

语法：字典.pop(key)

结果：获得指定key的Value，同时字典被修改，指定key的数据被删除

dict1={"张三":23,"李四":34,"赵五":21}
dict1.pop("张三")
print(dict1)

7.6清空元素

语法：字典.clear()

结果：字典被修改，元素被清空

dict1={"张三":23,"李四":34,"赵五":21}
dict1.clear()
print(dict1)

7.7获取全部的key

语法：字典.keys()

结果：得到字典中的全部key

dict1={"张三":23,"李四":34,"赵五":21}
dict_key=dict1.keys()
print(dict_key)

7.8遍历字典(不可以使用while)

方法一：
dict1={"张三":23,"李四":34,"赵五":21}
for key in dict1:
    print(key)
    value=dict1[key]
    print(value)
​
方法二：(通过获取全部的key，然后再遍历)
dict1={"张三":23,"李四":34,"赵五":21}
keys=dict1.keys()
for key in keys:
    print(key)
    value=dict1[key]
    print(value)

7.9统计字典内的元素数量——len

方法一：
count=0
dict1={"张三":23,"李四":34,"赵五":21}
for i in dict1:
    print(i)
    value=dict1[i]
    print(value)
    count+=1
print(count)
​
方法二：
dict1={"张三":23,"李四":34,"赵五":21}
print(len(dict1))

7.10Python 字典包含了以下内置方法

函数（方法）	描述
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
radiansdict.items()	以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys()	以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.values()	以列表返回字典中的所有值

8.数据类型转换

语句（函数）	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将对象x转换为字符串

num_str=str(11)
print(type(num_str),num_str)
​
float_str=str(11.334)
print(type(float_str),float_str)
​
num=int("11")
print(type(num),num)
​
num1=float("11.24")
print(type(num1),num1)
​
float_num=float(11)
print(type(float_num),float_num)
​
int_num=int(11.2)
print(type(int_num),int_num)
list1=[1,6,3,5,4,2]
set1={1,2,5,4,3}
tuple1=(1,3,2,4)
str1="abcd"
dict1={"key3":1,"key2":2,"key1":0}
#len()
print(len(list1))
print(len(set1))
print(len(tuple1))
print(len(str1))
print(len(dict1))
#min()
print(min(list1))
print(min(set1))
print(min(tuple1))
print(min(str1))
print(min(dict1))
#max
print(max(list1))
print(max(set1))
print(max(tuple1))
print(max(str1))
print(max(dict1))
​
#类型转换：容器转列表
print(list(list1))
print(list(tuple1))
print(list(str1))
print(list(set1))
print(list(dict1))
#类型转换：容器转元组
print(tuple(dict1))
print(tuple(tuple1))
print(tuple(str1))
print(tuple(set1))
print(tuple(dict1))
#类型转换：容器转字符串
print(str(list1))
print(str(tuple1))
print(str(str1))
print(str(set1))
print(str(dict1))
#类型转换：容器转集合
print(set(list1))
print(set(tuple1))
print(set(str1))
print(set(set1))
print(set(dict1))
​
#sorted排序
#sorted(容器,[reverse=True])
print(sorted(list1))
print(sorted(tuple1))
print(sorted(str1))
print(sorted(set1))
print(sorted(dict1))

二、标识符

1.标识符命名规则

1.1内容限制

• 英文

• 中文（不建议）

• 数字（不能开头）

• 下划线

1.2大小写敏感

1.3不可使用关键字

2.变量及变量名规范

• Python 可以同时为多个变量赋值，如 a, b = 1, 2。

• 一个变量可以通过赋值指向不同类型的对象。

• 见名知意

• 多个单词组合变量名，要用下划线做分隔

• 英文字母全小写

三、运算符

1.算术运算符

运算符	描述
+、-、*、\、%
//	取整除
**	指数

2.比较运算符

3.赋值运算符

4.位运算符

	按位与运算（a&b）	按位或运算(a|b)	按位异或（a^b）
a（60）的二进制表示	0011 1100	0011 1100	0011 1100
b（13）的二进制表示	0000 1101	0000 1101	0000 1101
运算结果	0000 1100	0011 1101	0011 0001
结果的十进制表示	12	61	49

	按位取反（~a）	左移（a<<2）	右移(a>>2)
a（60）的二进制表示	0011 1100	0011 1100	0011 1100
运算结果	1100 0011	1111 0000	0000 1111
运算结果的十进制表示	-61	240	15

5.逻辑运算符

运算符	逻辑表达式	描述
and	x and y	"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	"或" - 如果 x 是 True，它返回 x的值，否则它返回 y 的计算值。
not	not x	"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

6.成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	如果 x 在 y 序列中返回 True，否则返回False。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	如果 x 不在 y 序列中返回 True，否则返回False。

#coding=utf-8
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
    print ("变量a在给定的列表list中")
else:
    print ("变量a不在给定的列表list中")
if ( b not in list ):
    print ("变量b不在给定的列表list中")
else:
    print ("变量b在给定的列表list中")
​
# 修改变量a的值
a = 2
if ( a in list ):
    print ("变量a在给定的列表list中")
else:
    print ("变量a不在给定的列表list中")

7.身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 True
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 True

#coding=utf-8
a = 20
b = 20
if ( a is b ):
    print ("a和b有相同的标识")
else:
    print ("a和b没有相同的标识")
if ( id(a) == id(b) ):
    print ("a和b有相同的标识")
else:
    print ("a和b没有相同的标识")
​
# 修改变量 b 的值
b = 30
if ( a is b ):
    print ("a 和 b 有相同的标识")
else:
    print ("a 和 b 没有相同的标识")
if ( a is not b ):
    print ("a 和 b 没有相同的标识")
else:
    print ("a 和 b 有相同的标识")
（注：存储位置）

四、数据输入、输出

1.input()——输入

eg1:
print("请告诉我你是谁？")
name=input()
print("我知道了，你是%s" % name)
​
eg2:
name=input("请告诉我你是谁？")
print(f"我知道了，你是{name}，end=''" ) #end=''不换行

2.print()——输出

五、判断和循环

1.if

if 要判断的条件：
    条件成立要完成的事
​
#eg
age=20
if age>=18:
    print("我已经成年")
if 条件：
    满足条件时要做的事情
    ......
else：
    不满足条件时要做的事情
    ......
​
#eg
age=int(input("请输入您的年龄：")) #字符串类型
if age>=18:
    print("您已经成年，清补票的差价10元")
else
    print("您未成年。")
if 条件1：
    条件1满足的事情
    .....
 elif 条件2：
    条件2满足的事情
    ......
else:
    条件3满足的事情
    ......
​
#eg
age=int(input("请输入您的年龄：")) #字符串类型
if age>=60:
    print("您可以免费游玩")
elif age>=18:
    print("您已经成年，请补票的差价10元")
else:
    print("您未成年。")

2.match-case语句

match variable: #这里的variable是需要判断的内容
    case ["quit"]: 
        statement_block_1 # 对应案例的执行代码，当variable="quit"时执行statement_block_1    
    case ["go", direction]: 
        statement_block_2
    case ["drop", *objects]: 
        statement_block_3
    ... # 其他的case语句
    case _: #如果上面的case语句没有命中，则执行这个代码块，类似于Switch的default
        statement_block_default
​
#eg
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the Internet"

3.while条件

while 条件：
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
        ......
        
#案例
import random
num=random.randint(1,100)
count=0
flag=True
while flag:
    guess_num=int(input("请输入你猜的数字："))
    count+=1
    if guess_num==num:
        flag=False
        print("您以猜中")
    else:
        if guess_num>num:
            print("您输入的数字偏大")
        else:
            print("您输入的数字偏小")
print(f"一共猜了{count}次。")
​
count=9
row=line=1
while count:
    while row>=line:
        sum=line*row
        print(f"{line}*{row}={sum}\t",end='')#通过\t进行对齐；end=‘’不换行
        line+=1
    print("")
    row+=1
    line=1
    count-=1

4.for

for 临时变量 in 待处理数据集（序列）:
    循环满足条件时执行的代码
    
name="helloworld"
for x in name:
    print(x)

5.range

• range(num)

获取一个从0开始，到num结束的数字序列（不含num本身）

• range(num1,num2)

获取一个从num1开始，到num2结束的数字序列（不含num2本身）

• range(num1,num2,step)

获取一个从num1开始，到num2结束的数字序列（不含num2本身），数字之间的步长，以step为准（step默认为1）

变量作用域——循环内

count=9
row=line=1
for i in range(1,10):
    for j in range(1,i+1):
        sum=j*i
        print(f"{j}*{i}={sum}\t",end='')#通过\t进行对齐；end=‘’不换行
    print("")
    
import random
a=[random.randint(1,100) for i in range(10)] #[72,26,80,65,34,86,19,74,52,40]
print(max(a),min(a),sum(a)) #86 19 548

6.循环中断

6.1continue

跳出当前循环，继续进行下一轮循环。

6.2break

中止循环

六、函数

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

1.函数的使用

def 函数名（传入参数）：
    函数体
    return 返回值
​
#定义函数
def say_hi():
    print("Hello World!")
#调用函数
say_hi()
​
    
4.有返回值的函数
def add(a,b):
    result=a+b
    return=result
r=add(1,2)
print(r )
​
5.函数的嵌套
def func_a():
    print("-----2-----")
def func_b():
    print("-----1-----")
    func_a()
    print("-----3-----")
6.变量在函数中的作用
局部变量：定义在函数体内部的变量，即只在函数体内部生效（临时保存数据）
全局变量：在函数体内、外都能生效的变量

global关键字：在函数内修改全局变量

2.函数多种传参方式

有参数的函数
def add(a,b):
    #对函数进行说明文档
    """
    add函数可以接受2个参数，进行两个数相加的功能
    :param x:形参x表示相加的其中一个数字
    :param y:形参y表示相加的另一个数字
    :return:返回值是两个数相加的和
    """
    result=a+b
    print(f"{x}+{y}的结果是：{result}")

2.1位置参数

调用函数时根据函数定义的参数位置来传递参数

def user_info(name,age,gender):
    print(f”您的名字是'{name},年龄是{age},性别是{gender}“)
user_info("Tom",20,'男')
​
#不定长（元组）
def user_info(*arg):
    print(arg)
user_info("Tom",20,'男')
user_info("Jack")

2.2关键字参数

函数调用时通过”键=值“形式传递参数

作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

def user_info(name,age,gender):
    print(f”您的名字是'{name},年龄是{age},性别是{gender}“)
user_info(name="Tom",gender="男",age=20)
​
#不定长(字典)
def user_info(**arg):
    print(arg)
user_info(name="Tom",age=20,gender='男')
user_info(name="Jack")

2.3缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数定义和调用）

作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值。

def user_info(name,age,gender='男'):
    print(f”您的名字是'{name},年龄是{age},性别是{gender}“)
user_info("Tom",20,"女")
user_info("Jack",18)

2.4不定长参数

def arithmetic_mean(*l):
    if len(l) == 0:
        return 0
    else:
        sum = 0
        for x in l:
            sum += x
        return sum/len(l)
print(arithmetic_mean(45,32,89,78))
print(arithmetic_mean(8989.8,78787.78,3453,78778.73))
print(arithmetic_mean(45,32))

2.5函数作为参数传递

def test_fund(compute):
    result=compute(1,2)
    print(type(compute)) #function(函数)
    print(result)
    
def compute(x,y):
    return x+y
​
test_fund(compute)
​
#无参
def test_fund():
    result=compute(1,2)
    print(result)
    
def compute(x,y):
    return x+y
​
test_fund()

3.函数多返回值

#方式一
def test_return():
    return 1,2
x,y=test_return()
print(x) #1
print(y) #2
​
#方式二：支持不同类型的数据return
def test_return():
    return 1,"hello"
x,y=test_return()
print(x) #1
print(y) #hello
print(type(y)) #str

4.匿名函数

• def关键字，可以定义带有名称的函数

  有名称的函数，可以基于名称重复使用

• lambda关键字，可以定义匿名函数（无名称）

  无名称的匿名函数，只可临时使用一次

  语法：lambda 传入参数：函数体（一行代码）

#1
f=(lambda x,y:x*y)
print(f(2,4))
​
#2
def test_fund(compute):
    result=compute(1,2)
    print(result)
​
def compute(x,y):
    return x+y
​
test_fund(lambda x,y:x+y)

5.递归函数

def sum_recu(n): 
    if n>0: 
       return n +sum_recu(n-1) 
    else: 
       return 0 
       
sum = sum_recu(100) print(sum)

七、模块、包的导入与使用

1.Python模块

模块（module）：是一个Python文件，以.py结尾。每一个模块都可以帮助我们快速的实现一些功能。

1.1模块的导入

from 模块名 import (模块|类|变量|函数|*) as 别名
常用组合形式如：
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名

1.2自定义模块

def test(a,b):
    c=a+b
    print(c)
    
# from module import test
# test(2,9)
​
import module
module.test(1,5)

1.3测试模块

def test(a,b):
    c=a+b
    print(c)
​
if __name__ == '__main__':
    test(8,0)
#测试写的函数，在外面调用module的时候又不会运行所写的代码
--all--

2.Python包

包就是一个文件夹，里面可以存放许多Python的模块，通过包，在逻辑上将一批模块归为一类，方便使用。

—init—.py文件的作用？

创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹

—all—变量的作用

同模块中学习到的是一个作用，控制import * 能够导入的内容

def info_print1():
    print("我是模块1的功能函数代码")
   
def info_print2():
    print("我是模块2的功能函数代码")
​
#方式一
import my_package.my_module1
import my_package.my_module2
​
my_package.my_module1.info_print1()
my_package.my_module2.info_print2()
​
#方式二
from my_package import my_module1
from my_package import my_module2
my_package.info_print1()
my_package.info_print2()
​
#方式三
from my_package.my_module1 import info_print1
from my_package.my_module1 import info_print1
info_print1()
info_print2()

2.1安装第三方Python包

科学计算中常用的：numpy包
数据分析中常用的：pandas包
大数据计算中常用的：pyspark、apache-flink包
图形可视化常用的：matplotlib、pyecharts
人工智能常用的：tensorflow
python-docx（读取word）、xird（读取excel）
......
cmd
#方式一
pip install 包名称
pip list #查看安装包的列表
​
#方式二
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
​
#方式三
pycharm内直接安装

八.文件

1.文件的读取

open(name,mode,encoding)

with open(name,mode,encoding) as f:(不需要关闭文件)

• name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）

• mode:设置打开文件的模式：只读，写入，追加等

• encoding:编码格式（推荐使用UTF-8）

mode	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除
a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后；如果该文件不存在，创建新文件进行写入。

#打开文件——方式一
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
print(type(f))
f.close()
​
#打开文件——方式二
with open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8") as f:
    for line in f:
        print(line)

1.1read()

语法：文件对象.read(num)(num表示要从文件中读取的数据的长度（字节），如果没有传入num，就表示读取文件中所有的数据)

#打开文件
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
print(type(f))
print(f.read(10))

1.2readlines()

可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

#打开文件
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
print(type(f))
lines=f.readlines()
print(lines)
print(type(lines)

1.3readine()

#打开文件
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
print(type(f))
line1=f.readline()
print(line1)
line2=f.readline()
print(line2)
line3=f.readline()
print(line3)
​
#for循环
for line in f:
    print(line)
​
f.close()

1.4close()——文件关闭（内置flush()功能）

time.sleep(50000)——文件睡眠

#出现的次数
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
content=f.read()
count=content.count("快乐")
print(count)
​
#切分
f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","r",encoding="UTF-8")
for line in f:
    line=line.strip()#去除开头和结尾的空格
    words=line.split(" ")
    print(words)

2.文件的写入

f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","w")
f.write("hey world")
f.flush()

3.文件的追加

f=open("E:\\PythonProject\\PythonWork\\Data\\test.txt","a")
f.write("world")
#f.write("\n本书特色") #换行
f.close()

4.文件综合案例

#读取文件bill.txt
#将文件写出到 信息.txt 文件作为备份
#同时，将文件内标记为测试的数据行丢失
​
#实现思路
#open和r模式打开一个文件对象，并读取文件
#open和w模式打开另一个文件对象，用于文件写出
#for循环内容，判断是否是测试不是测试就write写出，是测试就continue跳过
#将2个文件对象均close（）
​
f1=open("E:\\PythonProject\\PythonWork\\Data\\bill.txt","r",encoding="UTF-8")
f2=open("E:\\PythonProject\\PythonWork\\Data\\信息.txt","w")
for line in f1:
    line=line.strip()
    if line.split("，")[4]=="测试":
        continue
    f2.write(line)
    f2.write("\n")
f1.close()
f2.close()

九.异常

处理异常的两种情况

1）整个程序因为一个bug停止运行

2）对bug进行提醒，整个程序继续运行——异常的捕获

1.异常的捕获方法

#基本捕获异常
try:
    可能发生错误的代码
excep:
    如果出现异常执行的代码
else:
    print("我是else，是没有异常的时候执行的代码")
finally 
    print("表示的是无论是否有异常都执行")
​
#捕获指定异常 
try:
    print(name)
excep NameError as e:
    print('name变量名称未定义错误')
    
#捕获多个异常 
try:
    1/0
excep (NameError,ZeroDivisionError) as e:
    print('name变量名称未定义错误')
    
#捕获所有异常
try:
    print(name)
excep Exception as e:
    print('name变量名称未定义错误')

2.异常的传递性

def func1():
    print("func1 开始执行")
    num=1/0
    print("func1 结束执行")
    
def func2():
    print("func2 开始执行")
    func1()
    print("func2 结束执行")
​
def main():
    func2()
​
main()

十、面向对象

1.类的定义和使用

class 类名称：
    类的属性（成员变量）
    类的行为（成员方法）
​
创建类对象的语法：
对象=类名称( )
​
在类中定义成员方法
def 方法名（self，形参1，......，形参N）：
    方法体

self关键字是成员方法定义的时候，必须填写的

• 它用来表示类对象自身的意思

• 当我们使用类对象调用方法的时候，self会自动被python传入

• 在方法内部，想要访问类的成员变量，必须使用self

#设计类（class）
class Student:
    name=None
    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")   
#创建对象
stu_1=Student()
stu_2=Student()
#对象属性赋值
stu_1.name="周杰伦"
stu_2.name="林俊杰"
​
#类的使用
class Student:
    name=None
    gender=None
    nationality=None
    native_place=None
    age=None
    
    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")
        
    def say_hi2(self,msg):
        print(f"Hi大家好，{msg}")
        #print(f"Hi大家好，{self.name},{msg}")
​
stu_1=Student()
stu_2=Student()
​
stu_1.name="周杰伦"
stu_1.gender="男"
stu_1.nationality="中国"
stu_1.native_place="中国台湾"
stu_1.age=34
​
stu_2.name="林俊杰"
stu_2.gender="男"
stu_2.nationality="新加坡"
stu_2.native_place="中国"
stu_2.age=34
​
print(stu_1.name,stu_1.gender,stu_1.nationality,stu_1.native_place,stu_1.age)
stu_1.say_hi()
print(stu_2.name,stu_2.gender,stu_2.nationality,stu_2.native_place,stu_2.age)
stu_2.say_hi() #调用的时候无需传参
stu_2.say_hi2("很高兴认识大家") #调用的时候，需要传msg参数（self透明）

2.内置方法（魔术方法）

__init__(self,)：构造方法，可用于创建类对象的时候设置初始化行为
- 在创建类对象（构建类）的时候，会自动执行
- 在创建类对象（构建类）的时候，将传入参数自动传递给__init__()方法使用 
__str__(self)：用于实现类对象转换字符串的行为
__lt__(self,other)：用于2个对象进行小于或大于比较
__le__(self,other)：用于2个对象进行小于等于或大于等于比较
__qe__(self,other)：用于2个对象进行相等比较
​
class Student:
    name=None
    age=None
    address=None
​
    def __init__(self,name,age,address):
        self.name=name
        self.age=age
        self.address=address
​
    def __str__(self):
        return f"name:{name}\nage:{age}\naddress:{address}"
​
    def __lt__(self, other):
        return self.age<other.age
​
    def __le__(self, other):
        return self.age<=other.age
​
    def __eq__(self, other):
        return self.age==other.age
​
stu1=Student("liu",9,"jfal")
stu2=Student("li",19,"jfa")
print(stu1<stu2)
print(stu1>stu2)
print(stu1>=stu2)
print(stu1==stu2)
​
# for i in range(1,3):
#     name = input(f"请输入第{i}位同学的姓名：")
#     age = input(f"请输入第{i}位同学的年龄：")
#     address = input(f"请输入第{i}位同学的地址：")
#     stu=Student(name,age,address)
#     print(stu)
#     # print(stu.name,stu.age,stu.address)
#     i = +1    

3.面向对象

面向对象的三大特性

• 封装

• 继承

• 多态

3.1封装

私有成员的访问限制

• 类对象无法访问私有成员

• 类中的其它成员可以访问私有成员

class Phone:
    __is_5g_enable=True
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")
​
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")
​
phone=Phone()
phone.call_by_5g()

3.2继承

继承的基础语法
#单继承
class 类名（父类名）:
    类内容体
    
#多继承：一个类，可以继承多个父类（如果父类有同名方法或属性，先继承的优先级高于后继承的）   
class 类名（父类1，父类2，父类3，......,父类N）:
    类内容体
（注：pass关键字：占位语句，用来保证函数，或类定义的完整性，表示内容空的意思）
​
class Phone:
    id=None
    producer="huawei"
​
    def call_by_4g(self):
        print("4g通话")
​
class Phone22:
    def call(self):
        print("第四代")
​
class Phone23(Phone,Phone22):
    face_id="1001"
    def call_by_5g(self):
        print("5g通话")
​
phone=Phone23()
print(phone.producer,phone.face_id)
phone.call_by_4g()
phone.call_by_5g()
phone.call()

复写和使用父类成员

复写：子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。即：在子类中重新定义同名的属性或方法即可。

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
class Child(Parent): # 定义子类
   def myMethod(self): #成员方法重写
      print ('调用子类方法')
​
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
调用父类成员：
方式1：父类名.成员变量
    父类名.成员方法(self)
方式2：super().成员变量
    super().成员方法(self)
​
class Phone:
    id=None
    producer="huawei"
​
    def call_by_4g(self):
        print("4g通话")
   
class Phone23(Phone):
    producer="hw"
    face_id="1001"
    #调用父类的成员变量
    #方式1
    print(f"父类的厂商是：{Phone.producer}")
    #方式2
    print(f"父类的厂商是：{super().producer}")
    def call_by_5g(self):
        print("5g通话")
​
phone=Phone23()
print(phone.producer,phone.face_id)
phone.call_by_4g()
phone.call_by_5g()
phone.call()

第八章

类型注解

ctrl+p

变量的类型注解

语法：变量：类型

功能：1.帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示

2.帮助开发者自身对变量进行类型注释（备注）

#基础数据类型注解
var_1:int=10
var_2:float=3.1415926
var_3:bool=true
var+4:str="jfakfl"
​
#类对象类型注解
class Student:
    pass
stu:Student=Student()
​
#基础容器类型注解
my_list:list[int]=[1,2,3] # type:int
my_tuple:tuple[str,int,bool]=("sjfka",2,True)
my_set:set={1,2,3}
my_dict:dict={"jjka":33}
my_str:str="fjakfalj"
​
#在注释中进行类型注解
#type:类型

函数的类型注解

def 函数方法名（形参名：类型，形参名：类型，......）:
    pass
​
def add(x:int,y:int):
    return x+y
​
#返回值注解
def 函数方法名(形参：类型，......，形参：类型) ->返回值类型:
    pass

Union类型

使用方式：导包：from typing import Union

使用：Union[类型，......，类型]

from typing import Union
#变量
my_list:list[Union[str,int]=["sjfa",2,3,"jlfa"] 
my_dict:dict[Union[str,int]]={"jjka":33,"jfal":11}
#函数
def add(data:Union[int,str])->Union[int,str]:
    return x+y

3.3多态

多态：指多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。

函数形参声明接收父类对象，实际传入父类的子类对象进行工作

（以父类做定义声明，以子类做实际工作，用以获得同一行为，不同状态）

class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪")
class Cat(Animal):
    def speak(self):
        print("喵喵")
​
def make_noise(animal:Animal):
    animal.speak()
​
dog=Dog()
cat=Cat()
make_noise(dog)
make_noise(cat)

4.抽象类（接口）

父类用来确定有哪些方法，具体的方法实现由子类自行决定

• 抽象的父类设计（设计标准）

• 具体的子类实现（实现标准）

抽象类：含有抽象方法的类

抽象方法：方法体实现的（pass）

5.类型注解

ctrl+p

功能：1.帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示

2.帮助开发者自身对变量进行类型注释（备注）

5.1变量的类型注解

语法：变量：类型
​
#基础数据类型注解
var_1:int=10
var_2:float=3.1415926
var_3:bool=true
var+4:str="jfakfl"
​
#类对象类型注解
class Student:
    pass
stu:Student=Student()
​
#基础容器类型注解
my_list:list[int]=[1,2,3] # type:int
my_tuple:tuple[str,int,bool]=("sjfka",2,True)
my_set:set={1,2,3}
my_dict:dict={"jjka":33}
my_str:str="fjakfalj"
​
#在注释中进行类型注解
#type:类型

5.2函数的类型注解

def 函数方法名（形参名：类型，形参名：类型，......）:
    pass
​
#返回值注解
def 函数方法名(形参：类型，......，形参：类型) ->返回值类型:
    pass
    
def add(x:int,y:int) ->int:
    return x+y

5.3Union类型

使用方式：导包：from typing import Union
         使用：Union[类型，......，类型]
​
from typing import Union
#变量
my_list:list[Union[str,int]=["sjfa",2,3,"jlfa"] 
my_dict:dict[Union[str,int]]={"jjka":33,"jfal":11}
#函数
def add(data:Union[int,str])->Union[int,str]:
    return x+y

十一、数据库

综合案例
创建到MySQL的数据库链接
​
from pymysql import Connection
conn=Connection(
    host='localhost', #主机名（或IP地址）
    port=3306, #端口，默认3306
    user='root', #账户名
    password='123456',#密码
    autocommit=True #自动提交确认
)
#打印MySQL数据库软件信息
print(conn.get_server_info())
#创建表
# cursor=conn.cursor() #获得游标对象
# conn.select_db("dbtest2")
# cursor.execute("create table teacher(id int);")
#查询
# cursor=conn.cursor()
# conn.select_db("dbtest2")
# cursor.execute("select * from student;")
# #获取查询结果
# results:tuple=cursor.fetchall()
# for r in results:
#     print(r)
#插入
cursor=conn.cursor()
conn.select_db("dbtest2")
cursor.execute("insert into student values(5,'李四',32,'男');")
#确认
#conn.commit()
#关闭到数据库的链接
conn.close()