Python 学习之路（上）

一、第一个Python程序

1, 打开Pycharm, 新建项目

2, 创建名为hello.py文件 (python文件以.py后缀结尾)

b, 在hello.py中输入以下内容
print("hello world")
c, 在代码区域右键, 选择’运行’文件

二、Python的编码规范

a.在每个语句的后面不要添加分号，每行最好只书写一条语句

b.括号的使用：运算符中

c.Python中是通过缩进【4个空格】来区分代码块的

d.尽量避免在文件名中出现中文和空格

三、注释

注释在编写程序的时候，给代码添加的一些解释性的文字

作用：可以提高代码的可读性，以便于以后的参考或者修改

注释是解释性文本，在运行程序的时候，会被自动的跳过，不做处理

分类
单行注释：只能注释掉单行的文字 # xxxxxxx

多行注释【块注释】：三个单引号或者三个双引号

注意：对于多行注释，选用单引号或者双引号都可以

如果单纯使用双引号，双引号的注释不能嵌套

四、常量和变量

1.常量

定义：在程序运行的过程中，值永远不会发生改变

print(2)
print(2.3)
print(3+5)print("hello")
print(True)

2.变量

2.1. 概念

定义: 程序在运行的过程中，值可以随时发生改变

作用：存储数据，参与运算

2.2. 定义

定义格式：变量名 = 初始值

说明：

变量名：对于每一个变量，需要给他定义一个名称，定义的规则就是标识符的规则

=：赋值运算符【主要是为了给变量进行赋值】, 不是数学中的等于,

初始值：第一次给变量赋予的值，在程序运行的过程中，这个值可以随时发生改变

举例：age = 10

age是变量名，10是初始值

#Python中的变量的定义和数学中变量的定义完全一致
x = 3
y = 4
print(x * y)x = "abc"
#print(x * y)#【扩展】
#Python被称为弱类型语言，动态改变变量的数据类型，容错性比较高
#Java被称为强类型语言，只要变量被定义，它的数据类型将不能发生任何的改变

2.3. 作用以及在内存中的存储

作用：需要在内存中开辟一块空间，将指定类型的值存储在这块空间中 age =18

思考问题：变量在内存中开辟了空间，那内存如何释放？

手动管理内存和自动管理内存

内存中的数据在不使用的情况会自动进行释放，当没有变量名【引用】指向某个实体的时候，则这个实体会被当做垃圾，只能等待系统的垃圾回收机制回收 GC

代码演示：
#给变量重新赋值
name1 = "叶良辰"
name2 = name1
print(name1)
print(name2)name1 = "Jack"
print(name1)
print(name2)

2.4.删除变量

注意：当定义一个变量，然后删除，相当于这个变量未被定义

代码演示：
#定义变量
num = 66
print(num)#删除变量
#del
#变量被删除之后则相当于这个变量未被定义
del num
print(num)

2.5.关键字

关键字: 在Python中，已经被赋予了特殊含义的英文单词
import keyword
print(keyword.kwlist)

2.6.标识符

在Python程序中自定义的一些英文单词

定义合法标识符的规则：

a.只能由数字，字母，下划线组成，不可以是其他的特殊字符【%，&，*，空格等】

b.开头不能是数字

c.不能是关键字

d. 严格区分大小写例如： age和Age是两个不同的标识符

定义标识符的规范：

a. Python官方要求: 全部用小写字母，不同单词之间使用下划线分隔 stu_score

遵循驼峰命名法【不同的单词之间使用首字母大写的方式进行分隔】

例如：stuScore StuScore

b. 尽量做到见名知意

【注意：规则和规范的区别】

练习：判断下面标识符合法是否

xiaoming 合法

$abc 不合法，有特殊字符

abc_hello 合法

1score 不合法，数字不能开头

score123 合法

扩展:

其他标识符的命名规则:

常量: 常量名所有字母大写，由下划线连接各个单词如MAX_OVERFLOW，TOTAL

函数&方法: 函数名应该为小写，可以用下划线风格单词以增加可读性。如：my_function，my_example_function。

文件名: 全小写,可使用下划线

包: 应该是简短的、小写的名字。如果下划线可以改善可读性可以加入

模块: 与包相同

类: 总是使用首字母大写单词串。如MyClass。内部类可以使用额外的前导下划线

五、输入输出【掌握】

1.print输出

作用：将一些特定的数据输出到屏幕上【调试工具】

代码演示：

#简单用法:每次只输出一个数据，任何类型都可以
print(10)
print("hello")#可以通过一条print输出多个数据,使用逗号隔开，最终得到的结果将逗号识别成了空格
print(10,"hello")x = 3
y = 4
print("x + y = ",x + y)

2.input输入

作用：可以将外部的值作为程序中变量的值使用【从控制台获取值】

代码演示：

#注意：当程序执行到input的时候，程序会停止在这个地方，等待用户的输入，
# 当内容输入结束之后，按下enter，此时输入结束
#用户输入的值可以通过变量的形式保存起来
str = input("请输入内容：")
print(str)name = input("请输入姓名：")
age  = input("请输入年龄：")
print(name,age)#需求:根据控制台输入的年龄计算还能活多少年, 假设可以活到100岁
death_age = 100#注意：通过input获取的数据全部都是字符串
age1 = input("请输入现在的年龄：")
print(death_age - age1)#字符串和整型之间的转换
"""
int:integer,整型，
str:string,字符串转换
int()  将字符串转换为整型
str()   将整型转换为字符串
float() 将整型或者字符串转换为浮点型【小数】
"""#修改上面的获取结果的语句
print("还可以活",death_age - int(age1),"年")
print("还可以活",str(death_age - int(age1)),"年")#练习：从控制台输入两个数，计算两个数的和，并将结果输出
num1 = int(input("请输入第一个数："))
num2 = int(input("请输入第二个数："))
print(num1 + num2)
result = num1 + num2
print(result)

六、Python中的数据类型

计算机顾明思议就是可以做数学运算的机器,因此计算机理所当然的可以处理各种数据,但是计算机能处理的远远不止数值,还有文本,图形,音频,视频网页等各种数据, 不同数据需要定义不同的数据类型

Number【数字：整型int，浮点型[小数]float，复数类型complex】

String【字符串】

Boolean【布尔类型】 True真（1）， Flase假（0）

None【空值】

list【列表】类似c语言的数组

tuple【元组】不可改变的列表

dict【字典】

set【集合】(了解)

bytes【字节】b’hello’

七、运算符和表达式

1.表达式

操作数和运算符组成, 比如: 1 + 1

作用: 表达式可以求值，也可以给变量赋值

2.运算符【掌握】

2.1. 算术运算符

+   -    *【乘法】   /【除法】   %【求余，取模】  **【求幂,次方】  //【取整】

代码演示：

num1 = 5
num2 = 3
print(num1 + num2)
print(num1 - num2)
print(num1 * num2)
print(num1 / num2)  #浮点型：1.6666666666666667    默认精度16位
print(num1 % num2)  #2
print(num1 ** num2) #5的3次方
print(num1 // num2) #获取浮点数的整数部分#除了+和-之外，其他的算术运算符都是相同的优先级
#出现优先级，解决办法使用括号
print((2 ** 5) * 3)

2.2. 赋值运算符

简单赋值运算符：= 给一个变量进行赋值

复合赋值运算符：+= -= %= /= … 给一个变量进行赋值，同时给变量进行相应的运算

代码演示：
#简单
num1 = 10
#注意：在赋值运算符中，先计算等号右边的表达式，然后将计算的结果赋值给等号左边的变量
num2 = num1 + 10
print(num2)#复合
num3 = 10
num3 += 100   #等价于num3 = num3 + 100
print(num3)

2.3. 关系【条件，比较】运算符

作用：比较大小，得到结果为布尔值【如果表达式成立，则返回True，如果不成立，则返回False】
>     <     >=    <=    ==【等号】    != 【不等于】
使用场景：if语句，循环

代码演示：
x = 3
y = 5
print(x > y)    #False
print(x < y)print(x == y)
print(x != y)print(x >= y)  #False
print(x <= y)  #True

2.4. 逻辑运算符

and : 与

or：或

not：非

2.5. 成员运算符和身份运算符

成员运算符:

in, not in

身份运算符:

is, is not

2.6. 位运算符【扩展】

前提：将数字转换为二进制使用

&【按位与】 |【按位或】 ^【按位异或】 ~【按位取反】 << 【左移】 >>【右移】

代码演示：
print(6 & 3)
print(6 | 3)
print(6 ^ 3)
print(~6)
print(6 << 2)
print(6 >> 2)

八、if语句【重点掌握】

1.代码结构

顺序结构：代码从上往下依次执行

分支结构：根据不同的条件，执行不同的语句

循环结构: 根据指定的条件，重复执行某段代码

2.分支结构-if语句

2.1简单if语句【单分支】

语法：

if 表达式：

执行语句

说明;要么执行，要么不执行，当表达式成立的之后，则执行语句；如果表达式不成立，则直接跳过整个if语句继续执行后面的代码

注意：表达式为真才执行语句

假：0 0.0 False “” None【空值】

一般情况下，表达式使用都是比较运算符

代码演示：
#单分支
num1 = 50
num2 = 60#需求：当num1 == num2,则给num1重新赋值为100#在pYthon中，通过缩进来区分代码块
if num1 != num2:num1 = 100print(num1)#练习：从控制台输入一个数，判断这个数是否是偶数
num = int(input())
if num % 2 == 0:print(num,"是一个偶数")print(num,"不是一个偶数")

2.2if-else语句【双分支】

语法：

if 表达式：

执行语句1

else:

执行语句2

说明：如果表达式成立，则执行语句1；如果不成立，则执行语句2

代码演示：
#双分支
#  从控制台输入一个数，判断这个数是否是偶数
num = int(input())if num % 2 == 0:print(num,"是一个偶数")
else:print(num,"不是一个偶数")#练习：从控制台输入一个数字，根据数字打印年龄段
age = int(input())
if age >= 18:print("成年人")
else:print("未成年人")

2.3if-elif-else语句【多分支】

语法：

if 表达式1：

执行语句1

elif 表达式2：

执行语句2

elif 表达式3：

执行语句3

。。。。。

else:

执行语句n

说明：实现了多选一的操作，会根据不同的条件从上往下来进行匹配，如果匹配上了，则执行对应的语句，然后直接结束整个if-elif语句，但是，如果所有的条件都不成立的话，则执行else后面的语句

注意：不管if-elif-else有多少个分支，都只会执行其中的一个分支

代码演示：
#多分支
#需求：从控制台输入一个数字，根据数字打印年龄段
age = int(input())
if age < 0:print("输入有误")
elif age <= 3:print("婴儿")
elif age <= 6:print("儿童")
elif age <= 12:print("青少年")
elif age <= 18:print("青年")
else:print("hello")

#练习：根据控制台输入的成绩，输出对应的等级
"""
90以上：优秀
80~90：良好
70~80：还行
70以下：加油吧，少年
"""
score = int(input("请输入学生的成绩："))
if score >= 90:print("优秀")
elif score >= 80:print("良好")
elif score >= 70:print("还行")
else:print("")#容易出现的问题：冒号     中文     空格

2.4三者之间的区别

代码演示：

#三者之间的区别
n = 3#多分支：多选一
if n > 1:print("a")
elif n > 2:print("b")
elif n > 3:print("c")
else:print("d")
#a#单分支：要么执行，要么不执行
if n > 1:print("a")
#a
if n > 2:print("b")
#b#双分支：实现二选一
if n > 3:print("c")
else:print("d")
#d

2.5嵌套if语句

语法：

if 表达式1：

执行语句1

if 表达式2：

执行语句2

说明：if语句的嵌套，可以在单分支，双分支，多分支之间进行任意组合

代码演示：
score = int(input("请输入学生的成绩："))
if score < 0 or score > 100:print("输入有误")
else:if score >= 90:print("优秀")elif score >= 80:print("良好")elif score >= 70:print("还行")else:print("")age = int(input("请输入年龄："))
looks = input("请输入您的相貌：")if age >= 18:if looks == "美女":print("要微信")else:print("略过")
注意：从语法角度来说，嵌套的层数没有任何的限制，但是，为了代码的可读性和可维护性，嵌套层数不要超过3层

九、list列表-上

1.概述

变量：使用变量存储数据，但是，缺点:一个变量每次只能存储一个数据

思考：如果一次性存储多个数据，怎么做？

解决：采用列表

作用：列表相当于是一个容器，可以同时存储多个数据

本质：列表是一种有序的集合

说明：有序指的就是有顺序【数据的存放的顺序和底层存储的顺序是相同的】

代码演示：
#需求：求5个人的平均年龄
age1 = 10
age2 = 13
age3 = 16
age4 = 39
age5 = 20#list
#在栈空间中有一个变量【列表的名字】
#变量指向了内存堆空间中的一个列表，列表中存储了5个变量
age_list = [10, 13, 16, 39, 20]

2.创建列表

语法：变量名 = 列表

列表名称 = [数据1，数据2.。。。。。]

说明：使用[ ]表示创建列表

列表中存储的数据被称为元素

列表中的元素被从头到尾自动进行了编号，编号从0开始，这个编号被称为索引，角标或者下标

索引的取值范围：0~元素的个数 - 1【列表的长度 - 1】

超过索引的范围：列表越界

代码演示：
#语法：列表名【标识符】 = [元素1，元素2.。。。。]
#1.创建列表
#1.1创建一个空列表
list1 = []
print(list1)#1.2创建一个带有元素的列表
list2 = [52,463,6,473,53,65]
print(list2)#2.思考问题：列表中能不能存储不同类型的数据？
list3 = ['abc',10,3.14,True]
print(list3)#注意：将需要存储的数据放到列表中，不需要考虑列表的大小，如果数据量很大的情况，在进行存储数据的时候，列表底层自动扩容

3.列表元素的访问

访问方式：通过索引访问列表中的元素【有序，索引：决定了元素在内存中的位置】

3.1获取元素

语法：列表名[索引]

代码演示：

#元素的访问
#创建列表
list1 = [5,51,6,76,98,3]#需求：获取索引为3的位置上的元素
num = list1[3]
print(num)
print(list1[3])

3.2替换元素

语法：列表名[索引] = 值

注意：列表中存储的是其实是变量，所以可以随时修改值

代码演示：

#需求：将索引为1位置上的元素替换为100
print(list1[1])
list1[1] = 100
print(list1[1])#问题：超过索引的取值范围，则会出现索引越界的错误
#解决办法：检查列表索引的取值范围
#print(list1[6])   #IndexError: list index out of range   索引越界

十、循环【掌握】

while循环+for循环

1.用法

语法：

初始化表达式

while 条件表达式：

循环体

循环之后操作表达式

for 变量名 in 列表：

循环体

功能：for-in循环主要用在列表中【实现列表的遍历：依次访问列表中的每一个元素，获取元素值】

说明;在列表中按照顺序获取元素值获取出来，赋值给变量，再执行循环体，如此往复，直到遍历到列表的最后一个元素

代码演示：
list1 = ["lisi","zhangsan","hack"]print(list1[0])
print(list1[1])
print(list1[2])#for循环
for name in list1:print(name)#while循环
index = 0
while index < len(list1):print(list1[index])index += 1#注意：for语句中操作的是列表中的元素，while语句中操作的是索引

2.range

range([start,]end[,step]) 注：[]表示start和step可写可不写

start:开始数字

end；结束数字

step；步长

start默认为0，step默认为1

功能：生成具有一定规律的序列

代码演示：

#range()
"""
range([start,]end[,step])
l例如：
range(100)    可以生成一个0~99的整数列表【不包含100】
range（1,100）  可以生成一个1~99的整数列表
range(1,100,2)  可以生成一个1~99之间的奇数列表
"""#需求1：计算1~100之间所有整数的和
num1 = 1
sum1 = 0
while num1 <= 100:sum1 += num1num1 += 1sum11 = 0
#借助于列表生成器生成一个1~100之间所有整数的列表，然后使用for循环进行遍历这个列表
for x in range(1,101):sum11 += x#需求2：计算1~100之间所有偶数的和
num2 = 1
sum2 = 0
while num2 <= 100:if num2 % 2 == 0:sum2 += num2num2 += 1num2 = 0
sum2 = 0
while num2 <= 100:sum2 += num2num2 += 2sum22 = 0
for y in range(0,101,2):sum22 += y

3.遍历列表

代码演示：

#列表的遍历
list2 = [23,54,6,45,56]
#1.直接操作的是元素
for num in list2:print(num)#2.通过索引的方式操作元素
#思路：使用列表生成器生成一个和索引有关的列表 0~len(list2) -1
for index in range(len(list2)):#index中保存的是0,1,2....n = list2[index]print(n)#3.同时遍历索引和元素
#enumerate  枚举【类似于一个容器】
#index,n1----->索引，元素值
for index,n1 in enumerate(list2):print(index,n1)

4.嵌套循环

代码演示：

#需求：打印九九乘法表#while实现
line = 1
while line <= 9:colum = 1while colum <= line:print("%dx%d=%d"%(colum,line,line*colum),end=" ")colum += 1print("")line += 1#for实现
#外层循环：控制行
for i in range(1,10):#内层循环：控制列for j in range(1,i + 1):print("%dx%d=%d"%(j,i,i*j),end=" ")print("")

十一. break、continue和pass语句的使用

1.break

作用:跳出循环【直接跳出整个循环，继续执行循环后面的代码】

代码演示：

#break的使用
#1.while
n = 0
while n < 5:print("n = %d"%(n))#print("n =" ,n)#注意：if语句充当的是一个条件判断if n == 3:breakn += 1
print("over")#2.for
list1 = [1,2,3,4,5]
for x in list1:print("x = %d"%(x))if x == 3:break
#结论：不管是while语句还是for语句，break的作用结束整个循环#3.特殊情况一
#不管while中的条件是否满足，else分支都会被执行
#思考问题：如果在while循环体中出现了break，else分支还会执行吗？-------不会
m = 0
while m < 3:print(m)if m == 1:breakm += 1
else:print("else")#4.特殊情况二
#当break使用在嵌套循环中的时候，结束的是当前循环【就近原则】
x = 0
y = 0
while x < 20:print("hello Python",x)x += 1while y < 5:print("hello Python~~~~",y)if y == 2:breaky += 1#break#注意：break是一个关键字，使用的过程中，单独就可以成为一条语句，后面不能跟任何的变量或者语句

2.continue

作用：跳出当前正在执行的循环，继续执行下一次循环

代码演示：

#continue的使用#1.for
for i in range(10):print(i)if i == 3:continueprint("*")for i in range(10):print(i)if i == 3:breakprint("*")#总结：continue只是结束当前正在执行的循环，而break表示直接结束整个循环# 2.while
"""
num = 0
while num < 10:print("num = %d"%(num))num += 1if num == 3:continue
"""
num = 0
while num < 10:if num == 3:num += 1continueprint("num = %d" % (num))num += 1

3.pass

Python中的pass是一条空语句

作用：为了保持代码结构的完整性，pass不做任何操作，只是充当了一个占位语句，保证代码可以正常的运行起来

应用场景：if，while，for中使用，可以在代码块的部分不添加任何语句，代码正常运行

代码演示：
while True:passprint("over")

4.练习

代码演示：

#需求;判断一个数是否是素数【质数】
#方式一
num1 = int(input("请输入一个数："))
#思路：一个数能被其他数整除，将次数记录下来
#条件：在2~num1 - 1的范围内，找到一个数能将num1整除，count1 + 1
count1 = 0
for i in range(2,num1):#整除：求余【大数对小数求余】if num1 % i == 0:count1 += 1if count1 == 0 and num1 != 1:print("是质数")
else:print("不是质数")#方式二：
#思路：假设num2是质数，寻找不成立的条件【有数能被整除】将假设推翻掉
num2 = int(input("请输入一个数："))
#定义一个布尔类型的变量，用于记录这个数是不是一个质数
is_prime  = True
for j in range(2,num2):if num2 % j == 0:is_prime = Falsebreakif is_prime == True and num2 != 1:print("是质数")
else:print("不是质数")

十二、list列表-下

1.列表的操作

1.1列表元素组合

代码演示：

#列表组合【合并】
#使用加号
list1 = [432,435,6]
list2 = ["abc","dhfj"]
list3 = list1 + list2
print(list3)  #[432, 435, 6, 'abc', 'dhfj']

1.2列表元素重复

代码演示：

#列表元素的重复
#使用乘号
list4 = [1,2,3]
list5 = list4 * 3
print(list5)  #[1, 2, 3, 1, 2, 3, 1, 2, 3]

1.3判断元素是否在列表中

代码演示：

#判断指定元素是否在指定列表中
#成员运算符   in  not in
list6 = [32,43,546,"hello",False]
print(43 in list6)
print(43 not in list6)
print(100 in list6)
print(100 not in list6)
"""
工作原理：使用指定数据在列表中和每个元素进行比对，只要元素内容相等，则说明存在的
True
False
False
True
"""

1.4列表截取【切片】

代码演示：

#列表的截取
list7 = [23,34,6,57,6878,3,5,4,76,7]
print(list7[4])#使用冒号:
#截取指定的区间：列表名[开始索引：结束索引],特点：包头不包尾    前闭后开区间
print(list7[2:6])#从开头截取到指定索引，特点：不包含指定的索引
print(list7[0:6])
print(list7[:6])#从指定索引截取到结尾
#注意：因为包头不包尾，所以如果要取到最后一个元素，可以超过索引的范围，不会报错
print(list7[4:20])
print(list7[4:])

2.列表的功能【掌握】

Python内置的功能【函数】

用法

代码演示：

#功能的使用：列表名.功能的名字()#一、添加元素
#1.append()   追加，在列表的末尾添加元素
#特点：是在原列表的基础上操作的
list12 = [1,2,3,4,5]
print(list12)
#追加单个元素
list12.append(6)
#追加多个元素,不能直接追加，通过列表的形式追加，形成了一个二维列表
list12.append([7,8])
print(list12)#2.extend()   扩展，在列表的末尾添加元素
#list12.extend(9)   TypeError: 'int' object is not iterable
list12.extend([9,10])
print(list12)#注意：append可以添加单个元素，但是extend不可以
#append添加多个元素的时候，以整个列表的形式添加进去；但是，extend只添加元素#3.insert()   插入 ,在指定的索引处插入一个元素,后面的其他元素向后顺延
#insert(索引，插入的数据)
list13 = [1,2,3,4,5]
print(list13)
#需求：在索引为2的位置插入一个数字100
list13.insert(2,100)
print(list13)
#将整个列表作为一个整体，插入到原列表中
list13.insert(2,[7,8])
print(list13)#二、删除元素
#1.pop()    弹出，移除列表中指定索引处的元素
list14 = [1,2,3,4,5]
print(list14)
#注意1：默认移除的是最后一个元素
#注意2：返回的是被移除的数据
result14 = list14.pop()
print(list14)  #[1, 2, 3, 4]
print(result14)   #5print(list14.pop(1))
print(list14)#2.remove()  移除   特点;移除指定元素在列表中匹配到的第一个元素【从左往右】
#remove(元素值)
list15 = [1,2,3,4,5,4,6,4]
print(list15)
list15.remove(4)
print(list15)#3.clear()      清除  清除列表中的所有的元素，原列表变为空列表
list16 = [25,36,673]
print(list16)
list16.clear()
print(list16)#三、获取
#直接使用功能：  功能名称(列表)
#1.len()    length,长度，获取列表的长度或者获取列表中元素的个数
list17 = [425.74,8,58679,7,65,65,64,6]
#索引的取值范围：0~len(list17) - 1
length = len(list17)
print(length)#2.max()  获取列表中的最大值
print(max(list17))#3.min() 获取列表中的最小值
print(min(list17))#4.index()     索引,从列表中匹配到的第一个指定元素的索引值
#index(元素值)
list18 = [10,20,30,40,50,30,40,50]
inx1 = list18.index(30)
print(inx1)   #2inx2 = list18.index(50)
print(inx2)   #4#5.count()   个数，查找指定元素在列表中出现的次数
print(list18.count(50))   #2#四、其他用法
#1.reverse()      反转，将列表中的元素倒序输出
list19 = [10,20,30,40,50]
#注意;在列表的内部进行反转，并没有生成新的列表
list19.reverse()
print(list19)#2.sort()    排序,默认为升序排序   注意：在列表的内部操作
list20 = [34,65,768,23]
#列表名.sort()
#升序
#list20.sort()
#降序
list20.sort(reverse=True)
print(list20)#3.sorted()  排序,默认为升序排序   注意：生成一个新的列表
list21 = [34,65,768,23]
#升序
#list22 = sorted(list21)
#print(list22)
#降序
list23 = sorted(list21,reverse=True)
print(list23)#按照元素的长度来进行排序
list00 = ["abc","hello","g","fhekfgjahgjkq"]
list24 = sorted(list00,key=len)
print(list24)#4.拷贝【面试题】
list25 = [23,3,546]
list26 = list25
list26[1] = 100
print(list25)    #[23, 100, 546]
print(list26)    #[23, 100, 546]
print(id(list25))
print(id(list26))#浅拷贝：内存的拷贝【实体，堆空间】
list27 = [23,3,546]
list28 = list27.copy()
list28[1] = 200
print(list27)
print(list28)
print(id(list27))
print(id(list28))#深拷贝
list1 = [23,3,[4,5]]
list2 = copy.deepcopy(list1)#练习：remove()
list30 = [23,435,5656,6767,435,23,23,54,64,5676,23,23,23]
#需求：移除列表中指定的所有的元素，例如：23
"""
list30.remove(23)
print(list30)
list30.remove(23)
print(list30)
list30.remove(23)
print(list30)
list30.remove(23)
print(list30)
list30.remove(23)
print(list30)
"""
#定义一个变量，用于记录元素的位置【索引】
#问题：remove功能是在列表的内部操作的
num = 0
#length = len(list30)
all  = list30.count(23)
while num < all:#依据：remove每次删除的第一次匹配的元素【从左到右】list30.remove(23)num += 1
print(list30)

3.二维列表

一个列表的元素是一个列表

代码演示：

#一维列表
list1 = [1,23,5,346]
#二维列表
list2 = [[543,54,6],[234,35,46,4565,767],[65,65,65,565]]#处理二维列表：当做一个一维列表使用
subList = list2[1]
print(subList)
print(subList[2])

十三、布尔值和空值

1.布尔值

一个布尔类型的变量一般有两个值，True,False

作用：用于分支和循环语句中作为条件判断

代码演示：
#Boolean
b1 = True
b2 = False#条件表达式或者逻辑表达式结果都是布尔值
print(4 > 5)
print(1 and 0)

2.空值

Python中的一种特殊的数据类型，使用None表示

区别与0：0是数字类型，None本身就是一种数据类型

代码演示：
#空值
n = None
print(n)   #None

十四、数字类型Number

1.分类

1.1整数

可以处理Python中任意大小的整型

代码演示：

num1 = 10
num2 = num1
print(num1,num2)#1.可以连续定义多个同种类型的变量,初始值相同
num3 = num4 = num5 = 100#2.同时定义多个变量，初始值不同
num6,num7 = 60,70
print(num6,num7)#3.可以交换两个变量的值【掌握】
#自己实现
nn1 = 22
nn2 = 33
temp = nn1
nn1 = nn2
nn2 = temp
print(nn1,nn2)n1 = 22
n2 = 33
print(n1,n2)   #22  33
n1,n2 = n2,n1
print(n1,n2)#4.获取变量在内存中的地址
print(id(num1),id(num2))

1.2浮点数

由整数部分和小数部分组成

注意：浮点数在计算机中运算的时候可能会出现四舍五入

2.系统功能

2.1数学功能

abs(x): absolute 求x的绝对值

max(): 求最大值

min()：求最小值

pow(n,m):求一个数的多少次幂

round(x，n):返回浮点数x的四舍五入值,如果给出n值，则表示舍入到小数点后几位

代码演示：
print(abs(-10))print(max(23,34,6,56,57,6))
print(min(23,34,6,56,57,6))print(pow(3,5))print(round(3.456))   #3
print(round(3.656))   #4
print(round(3.656,2))  #3.66
print(round(3.646,1))   #3.6
导入math模块，math.功能名()

代码演示：
#以下的功能必须导入math模块
import  math#使用格式：math.功能名称#19向上取整
print(math.ceil(18.1))
print(math.ceil(18.9))#18向下取整
print(math.floor(18.1))
print(math.floor(18.9))#求平方
print(pow(3,2))
#开平方【掌握】
print(math.sqrt(9))#获取整数部分和小数部分，得到的结果为元组
print(math.modf(22.3))

2.2随机数random【掌握】

代码演示：

import random#1.random.choice(列表)  从指定列表中随机选择一个元素出来
#指定列表
num1 = random.choice([1,3,5,7,9])
print(num1)#列表生成器
num2 = random.choice(range(5))   #等价于[0,1,2,3,4]
print(num2)#使用字符串，相当于使用了元素为字母的列表
num3 = random.choice("hello")  #等价于["h","e","l","l","o"]
print(num3)#需求;产生一个4~10之间的随机数
print(random.choice([4,5,6,7,8,9,10]))
print(random.choice(range(4,11)))#2.random.randrange(start,end,step)
"""
start:指定范围的开始值，包含在范围内，默认为0
end:指定范围的结束值，不包含在范围内
step:步长，指定的递增基数，默认为1
"""#需求1：从1~100之间选取一个奇数随机数
print(random.choice(range(1,100,2)))
print(random.randrange(1,100,2))
#需求2：生成一个0~99之间的随机数
print(random.randrange(100))#3.random.random()   获取0~1之间的随机数，结果为浮点型
n = random.random()
#需求：保留小数点后两位
print(round(n,2))#需求1：获取4~10之间的随机数
n1 = random.random() * 6 + 4
"""
[0,1] * 6 --------->[0,6]
[0,6] + 4 -------->[4,10]
"""#4.将列表中的元素进行随机排序【了解】
list1 = [23,5435,4,6]
random.shuffle(list1)
print(list1)#5.随机生成一个实数，它在[3,9]范围内，结果为浮点型
print(random.uniform(3,9))#需求：求50~100之间的随机数，包括浮点数
n2 = random.uniform(50,100)

2.3三角函数功能【了解】

十五、tuple元组

1.概述

和列表相似，本质上是一种有序的集合

元组和列表的不同之处：

a.列表:[ ] 元组：( )

b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】

2.创建元组

创建列表:

创建空列表：list1 = []

创建有元素的列表：list1 = [元素1，元素2，。。。。。]

创建元组

创建空元组：tuple1 = ()

创建有元素的元组：tuple1 = (元素1，元素2，。。。。)

代码演示：
#创建空元组：
tuple1 = ()#创建有元素的元组：
tuple2 = (10,20,30)#在元组中可以存储不同类型的数据
tuple3 = ("hello",True,100)#注意：创建只有一个元素的元组
#按照下面的方式书写，表示定义了一个整型的变量，初始值为1
tuple4 = (1)
tuple4 = 1
#为了消除歧义，修改如下：
tuple4 = (1,)num1 = 10
num2 = (10)
print(num1,num2)

3.元组元素的访问

代码演示：

#元组元素的访问
#格式：元组名[索引],和列表完全相同
tuple1 = (10,20,30,40,50)
#1.获取元素值
print(tuple1[2])
#获取元组中的最后一个元素
print(tuple1[4])
#print(tuple1[5])  #IndexError: tuple index out of range  索引越界#正数表示从前往后获取，负数表示从后往前获取
print(tuple1[-1])
print(tuple1[-2])
print(tuple1[-5])
# print(tuple1[-6])   #IndexError: tuple index out of range  索引越界#2.修改元素值----->不能修改，本质原因不能修改元素的地址
#和列表不同的地方：元组的元素值不能随意的更改
#tuple1[1] = 100
tuple2 = (1,35,54,[4,5,6])
#获取元组中列表中的元素
print(tuple2)   #(1, 35, 54, [4, 5, 6])
tuple2[3][1] = 50
print(tuple2)  #(1, 35, 54, [4, 50, 6])#3.删除元组
tuple3 = (53,6,7,76)
del tuple3

4.元组操作

代码演示：

#1.元组组合
#+
tuple1 = (3,43,5,4)
tuple2 = (3,5,45,4)
print(tuple1 + tuple2)#2.元组重复
#*
print(tuple1 * 3)#注意：元组组合和元组重复得到的是一个新的元组，原来的元组并没有发生任何改变#3.判断元素是否在元组中
#成员运算符
#in    not in
print(100 in tuple1)
print(100 not in  tuple1)#4.元组截取【切片】
tuple3 = (1,23,43,54,54,656,57,6)
print(tuple3[2:4])
print(tuple3[2:])
print(tuple3[:4])

5.元组功能

代码演示：

#1.获取元组的元素个数
tuple1 = (54,3,5,46,56)
print(len(tuple1))#2.获取元组中元素的最大值和最小值
print(max(tuple1))
print(min(tuple1))#3.元组和列表之间的相互转换:取长补短
#3.1   元组-----》列表
#list()
list1 = list(tuple1)    #int()   float()
print(list1)#3.2  列表------》元组
#tuple()
list2 = [34,5,46,4]
tuple2 = tuple(list2)
print(tuple2)#4.遍历元组
#4.1直接遍历元素
for element in tuple1:print(element)#4.2遍历索引
for index in range(len(tuple1)):print(tuple1[index])#4.3同时遍历索引和元素
for i,num in enumerate(tuple1):print(i,num)

6.二维元组

代码演示：

#当做一维元组进行处理，实质：一维元组中的元素为一个一维元组
tuple1 = ((2,43,5),(54,65,6),(5,54,54,54))
print(tuple1[1][1])#遍历二维列表或者二维元组的思路：嵌套循环
#遍历外层元组
for element in tuple1:#遍历内层元组for num in elment:print(num)

十六、字典Dict

1.概念

列表和元组的使用缺点：当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦
# 定义一个列表保存，姓名、性别、职业
nameList = ['尼古拉斯.赵四', '男', '铁憨憨'];# 当修改职业的时候，需要记忆元素的下标
nameList[2] = '演员'  # 如果列表的顺序发生了变化，添加年龄
nameList = ['尼古拉斯.赵四', 18, '男',  '铁匠']# 此时就需要记忆新的下标，才能完成名字的修改
nameList[3] = 'xiaoxiaoWang'
解决方案：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素，采用字典

语法： {键1: 值1, 键2: 值2, 键3: 值3, …, 键n: 值n}

说明：键值对: key-value

字典和列表类似，都可以用来存储多个数据

在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）

字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型

每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value

习惯使用场景：

列表更适合保存相似数据，比如多个商品、多个姓名、多个时间

字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息

2.定义字典

#语法：字典名 = {key1:value1,key2:value2.....}#1.创建空字典
dict1 = {}
print(dict1,type(dict1))#2.创建非空字典
#方式一
dict21 = {"name":"张三","age":18}
print(dict21)#方式二
#dict(key=value),key是一个变量名，value是一个值
dict22 = dict(a="avvv",b="2353")
print(dict22)
dict22 = dict(a=200,b=33)
print(dict22)#方式三
#dict()和zip(序列),zip表示映射
#dict(zip([key1,key2,key3....],[value1,value2,value3....]))
#注意：key的数量和value的数量可以不一致，以少的作为参考
z1 = zip([1,2],["a","b","c"])
dict23 = dict(z1)
print(dict23)dict23 = dict(zip(("name","age"),("aaa",10)))
print(dict23)dict23 = dict(zip("xyz","abc"))
print(dict23)#方式四
# [(key1,value1), (key2,value2)...] => {key1:value1, key2:value2....}
dict24 = dict([("a",10),("b",20),("c",30)])
print(dict24)

十七、set集合【了解】

1.概述

和数学上的集合基本是一样的，

特点:不允许有重复元素，可以进行交集，并集，差集的运算

本质：无序，无重复元素的集合

2.创建

set(列表或者元组或者字典)

代码演示：

#注意：set的创建需要借助于list和tuple#1.通过list创建set
list1 = [432,5,5,46,65]
s1 = set(list1)
print(list1)
print(s1)#注意1：set中会自动将重复元素过滤掉#2.通过tuple创建set
tuple1 = (235,45,5,656,5)
s2 = set(tuple1)
print(tuple1)
print(s2)#3.通过dict创建set
dict1 = {1:"hello",2:"good"}
s3 = set(dict1)
print(dict1)   #{1: 'hello', 2: 'good'}
print(s3)   #{1, 2}#注意2：set跟dict类似，都使用{}表示，但是与dict之间的区别在于：set中相当于只存储了一组key，没有value

3.操作

3.1添加

代码演示：

#1.添加
#add()   在set的末尾进行追加
s1 = set([1,2,3,4,5])
print(s1)
s1.add(6)
print(s1)#注意：如果元素已经存在，则添加失败
s1.add(3)
print(s1)
#print(s1.add(3))#s1.add([7,8,9])   #TypeError: unhashable type: 'list'  list是可变的，set中的元素不能是list类型
s1.add((7,8,9))
#s1.add({1:"a"})  #TypeError: unhashable type: 'dict'  ，dict中的键值对可以改变，set中的元素不能是dict类型
print(s1)#update()   插入【末尾添加】，打碎插入【直接将元组，列表中的元素添加到set中，将字符串中的字母作为小的字符串添加到set中】
s2 = set([1,2,3,4,5])
print(s2)
s2.update([6,7,8])
s2.update((9,10))
s2.update("good")
#注意：不能添加整型，因为整型不能使用for循环遍历
#s2.update(11)   #TypeError: 'int' object is not iterable
print(s2)

3.2删除

代码演示：

#2.删除
#remove()
s3 = set([1,2,3,4,5])
print(s3)
s3.remove(3)
print(s3)

3.3遍历

代码演示：

#3.set的遍历
s4 = set([1,2,3,4,5])
for i in s4:print(i)#注意：set是没有索引的，所以不能通过s4[2]获取元素，原因：set是无序的
#print(s4[2])  #TypeError: 'set' object does not support indexing#注意：获取的是编号和元素值
for i,num in enumerate(s4):print(i,num)

3.4交集和并集

代码演示：

#4.交集和并集
s4 = set([1,2,3])
s5 = set([4,5,3])#交集：&【按位与】    and
r1 = s4 & s5
print(r1)
print(type(r1))#并集:|【按位或】   or
r2 = s4 | s5
print(r2)

十八、排序算法

1. 冒泡排序

排序思路：比较两个相邻下标对应的元素，如果以升序为例的话，则最大值出现在最右边

代码实现：

list1 = [34,5,46,23,23,54,65,54]#升序排序：冒泡
#外层循环：控制比较的轮数
for out in range(0,len(list1) - 1):#内层循环;控制每一轮比较的次数，兼顾参与比较的下标for inner in range(0,len(list1) - out - 1):if list1[inner] > list1[inner + 1]:list1[inner],list1[inner + 1] = list1[inner + 1],list1[inner]print(list1)

2. 选择排序

排序思路：固定一个下标，然后拿这个下标对应的元素和其他的元素依次进行比较，最小值出现在最左边

十九、String字符串基础

1.概述

由多个字母，数字，特殊字符组成的有限序列

在Python中，使用单引号或者双引号都可以表示字符串

注意:没有单符号的数据类型

‘a’ “a”

2.创建字符串

代码演示：

str1 = "hello"
str2 = "abc1234"
str3 = "***fhhg%%%"
str4 = "中文"

3.字符串运算

代码演示：

#1.+   字符串连接
s1 = "welcome"
s2 = " to China"
print(s1 + s2)#注意：在Python中，使用+。只能是字符串和字符串之间。和其他数据类型使用的话不支持
#print("abc" + 10)
#print("123" + 1)
#print(1 + "12" + 12)
#print("hello" + True)#2. *   字符串重复
s3 = "good"
print(s3 * 3)#3.获取字符串中的某个字符
"""
类似于列表和元组的使用，通过索引来获取指定位置的字符
注意索引的取值范围【0~长度 - 1】，同样会出现索引越界
访问方式：字符串名称[索引]
"""
s4 = "abcdef"
print(s4[1])
#print(s4[10])  #IndexError: string index out of range#获取字符串的长度：len()
#遍历字符串,和list，tuple的用法完全相同
for element in s4:print(element)
for index in range(0,len(s4)):print(s4[index])
for index,str in enumerate(s4):print(index,str)#4.截取字符串【切片】
str1 = "hello world"
#指定区间
print(str1[3:7])
#从指定位置到结尾，包含指定位置
print(str1[3:])
#从开头到指定位置，但是不包含指定位置
print(str1[:7])str2 = "abc123456"
print(str2[2:5]) #c12
print(str2[2:])  #c123456
print(str2[2::2])  #c246
print(str2[::2])   #ac246
print(str2[::-1])  #654321cba   倒序
print(str2[-3:-1])  #45   -1表示最后一个字符#5.判断一个子字符串是否在原字符串中
#in  not in
str3 = "today is a good day"
print("good"  in str3)
print("good1"  not in str3)

4.格式化输出

通过%来改变后面字母或者数字的含义，%被称为占位符

%d 整数

%f 浮点型，特点：可以指定小数点后的位数

%s 字符串

代码演示：
#6.格式化输出
num = 10
string1 = "hello"
print("string1=",string1,"num=",num)
#注意：变量的书写顺序尽量和前面字符串中出现的顺序保持一致
print("string1=%s,num=%d"%(string1,num))f = 12.247
print("string1=%s,num=%d,f=%f"%(string1,num,f))
#需求：浮点数保留小数点后两位
print("string1=%s,num=%d,f=%.2f"%(string1,num,f))    #round(12.247,2)

5.常用转义字符

通过\来改变后面字母或者特殊字符的含义

\t 相当于tab键

\n 相当于enter键

\b 相当于backspace

代码演示：

#7.转义字符
string2 = "hello\tworld"
string21 = "hello   world"
print(string2)
print(string21)#换行：\n    多行注释
string3 = "hello\nPython"
string31 = """hello
python2354623
"""
print(string3)
print(string31)#需求："hello"
print("\"hello\"")#C:\Users\Administrator\Desktop\SZ-Python1805\Day6\视频
print("C:\\Users\\Administrator\\Desktop")
#注意;如果一个字符串中有多个字符需要转义，则可以在字符串的前面添加r,可以避免对字符串中的每个特殊字符进行转义
print(r"C:\Users\Administrator\Desktop")

二十、string字符串【掌握】

1.常用功能

1.1获取长度和次数

代码演示：

#1.计算字符串长度  len
#类似于list和tuple的中获取长度的用法
str1 = "hfufhja"
l = len(str1)
print(l)#2,计算某个字符或者子字符串在原字符串中出现的次数   count
str2 = "this is a good day good day"
#count(str,[start,end])
#在整个字符串中进行查找
print(str2.count("day"))
#在指定区间内进行查找
print(str2.count("day",3,10))

1.2大小写转换

代码演示：

#注意：使用字符串中的功能，一般情况下，都是生成一个新的字符串，原字符串没有发生任何变化
#3.大小写字母转换
#lower()   将字符串中的大写字母转换为小写
str31 = "Today Is a Good day"
astr31 = str31.lower()
print(astr31)#upper()   将字符串中小写字母转换为大写
str32 = "Today Is a Good day"
astr32 = str2.upper()
print(astr32)#swapcase()     将字符串中小写字母转换为大写，大写字母转换为小写
str33 = "Today Is a Good day"
astr33 = str33.swapcase()
print(astr33)#capitalize()   将一句英文中首单词的首字母转化为大写，其他小写
str34 = "today Is a Good day"
astr34 = str34.capitalize()
print(astr34)#title()       将一句英文中每个单词的首字母大写
str35 = "today is a good day"
astr35 = str35.title()
print(astr35)

1.3整数和字符串转换

代码演示：

4.字符串和数字之间的转换
#int()     float()      str()
#eval(str)   将str转换为有效的表达式，参与运算，并返回运算结果
num1 = eval("123")
print(num1)
#print("123")
print(type(num1))
print(int("123"))#eval和int将+和-当做正负号处理
print(eval("+123"))
print(int("+123"))
print(eval("-123"))
print(int("-123"))#将12+3字符串转换为了有效的表达式，并运算了结果
print(eval("12+3"))    #15
#不成立
#print(int("12+3"))   #ValueError: invalid literal for int() with base 10: '12+3'print(eval("12-3"))   #9
#print(int("12-3"))    #ValueError: invalid literal for int() with base 10: '12-3'#print(eval("a123"))  #NameError: name 'a123' is not defined
#print(int("a123"))  #ValueError: invalid literal for int() with base 10: 'a123'#总结：注意区分eval和int【eval：转换有效的表达式   int:将字符串转换为整型】

1.4填充

代码演示：

#5.填充【了解】
#center（width[,fillchar]）  返回一个指定宽度的居中字符串，width是填充之后整个字符串的长度，fillchar为需要填充的字符串，默认使用空格填充
str1 = "hello"
print(str1.center(20))
print(str1.center(10,"*"))#ljust（width[,fillchar]） 返回一个指定宽度的字符串，将原字符串居左对齐，width是填充之后整个字符串的长度
print(str1.ljust(40,"%"))#rjust width[,fillchar]）  返回一个指定宽度的字符串，将原字符串居右对齐，width是填充之后整个字符串的长度
print(str1.rjust(40,"%"))#zfill（width）   返回一个指定宽度的字符串,将原字符串居右对齐,剩余的部分使用的数字0填充
print(str1.zfill(40))

1.5查找

代码演示：

#6.查找【掌握】
str2 = "abcdefhello123hello"
#find（str[,start,end]）  从左到右依次检测，str是否在原字符串中，，也可以指定查找的范围
#特点;得到的子字符串第一次出现的开始字符的下标，如果查找不到则返回-1
print(str2.find("hello"))    #6
print(str2.find("e"))
print(str2.find("yyy"))    #-1
print(str2.find("e",3,10))#rfind(str[,start,end]）   类似于find，从右向左进行检测
print(str2.rfind("hello"))  #14#index   和find的使用基本相同，唯一的区别在于如果子字符串查找不到，find返回-1，而index则直接报错
print(str2.index("hello"))
#print(str2.index("yyy"))   #ValueError: substring not found#rindex  和rfind的使用基本相同#max(str)   获取str中最大的字母【在字典中的顺序】
#"abcdefhello123hello"
print(max(str2))str3 = "46732647"
print(max(str3))#min（str）  获取str中最小的字母【在字典中的顺序】

1.6提取

代码演示：

#7.提取字符串
#strip(str)    使用str作为条件提取字符串，除了两头指定的字符串
str1 = "********today is *********a good day*******"
print(str1.strip("*"))   #today is *********a good day#lstrip(str)    提取字符串，除了左边的指定字符串
str11 = "********today is *********a good day*******"
print(str11.lstrip("*"))#rstrip()
str12 = "********today is *********a good day*******"
print(str12.rstrip("*"))

1.7分割和合并

代码演示：

#8.分割和合并【掌握】
#split(str[,num)]   将str作为分隔符切割原字符串，结果为一个列表,如果制定了num，则仅使用num个字符串截取原字符串
str3 = "today is a good day"
print(str3.split(" "))   #['today', 'is', 'a', 'good', 'day']
print(str3.split(" ",2))   #['today', 'is', 'a good day']#splitlines(flag)   按照换行符【\n，\r,\r\n】分隔，结果为列表
#flag:False或者不写，则表示忽略换行符；如果True，则表示保留换行符
str4 = """today
is
a
good
day
"""
print(str4.splitlines(True))   #['today', 'is', 'a', 'good', 'day']    ['today\n', 'is\n', 'a\n', 'good\n', 'day\n']#join(list)    将原字符串作为连接符号，将列表中的元素分别连接起来，结果为字符串，作用和split是相反的
str5 = "*"
list1 = ["shangsan","lisi","jack"]
print(str5.join(list1))

1.8替换

代码演示：

#9.替换
#replace(old,new[,max])   用new的字符串将old的字符串替换掉.max表示可以替换的最大次数【从左到右】
str1 = "this is a easy test test test test"
print(str1.replace("test","exam"))
print(str1.replace("test","exam",2))#使用场景：在一定情境下，可以实现字符串的简单加密，加密规则可以自定义
#maketrans()   创建字符映射的转换表,结果为字典，通过key:value的方式
#translate(table)t = str.maketrans("aco","123")
print(t)   #{97: 49, 99: 50, 111: 51}str2 = "today is a good day"
print(str2.translate(t))  #t3d1y is 1 g33d d1y

1.9判断

代码演示：

#10.判断
#isalpha()   如果字符串中至少包含一个字符并且所有的字符都是字母，才返回True
print("".isalpha())
print("abc".isalpha())
print("abc123".isalpha())   #False#isalnum   如果字符串中至少包含一个字符并且所有字符都是字母或者数字的时候才返回True
print("".isalnum())   #False
print("abc".isalnum())
print("abc123".isalnum())
print("123".isalnum())
print("1abc".isalnum())
print("1abc￥".isalnum())  #False#isupper  如果字符串中至少包含一个字符并且出现的字母必须是大写字母才返回True，数字的出现没有影响
print("".isupper())
print("aBC".isupper())
print("123A".isupper())   #True
print("abc".isupper())#islower#istitle   每个单词的首字母必须全部大写才返回True
print("Good Day".istitle())
print("good Day".istitle())#isdigit() 【掌握】   如果字符串中只包含数字，则返回True
print("abc123".isdigit())
print("2364".isdigit())#需求：将用户从控制台输入的字符串转化为整型【全数字】
str = input()
if str.isdigit():int(str)print("yes")

1.10前缀和后缀

代码演示：

#11.前缀和后缀【掌握】  子字符串是连续的
#startswith
str1 = "helloPython"
print(str1.startswith("hello"))#endswith
print(str1.endswith("on"))

1.11编解码

代码演示：

#12.字符串编码和解码
#注意：主要针对的是中文
#encode()   默认的编码格式为utf-8
str2 = "this is 千锋教育"
print(str2.encode())
print(str2.encode("utf-8"))
print(str2.encode("gbk"))#decode()   bytes对象
#\xe5\x8d\x83\xe9\x94\x8b\xe6\x95\x99\xe8\x82\xb2
#print(r"\xe5\x8d\x83\xe9\x94\x8b\xe6\x95\x99\xe8\x82\xb2".decode())    错误

1.12ASCII码转换

代码演示：

#13。ASCII吗的转换
#ord()
print(ord("A"))
print(ord("0"))#chr()
print(chr(65))
print(chr(110))

二十一、函数

1.函数概述

1.1认识函数

需求: 求圆的面积

s = π r²
# 勾股定理
c = math.sqrt(a**2 + b**2)
代码演示：
r1 = 6.8
s1 = 3.14 * r1 ** 2r2 = 10
s1 = 3.14 * r2 ** 2r3 = 2
s1 = 3.14 * r3 ** 2r4 = 30
s1 = 3.14 * r4 ** 2# 函数/公式
f(x,y) = 2x + y + 1
f(1) = 2*1 + 1#define
def test(r):s = 3.14 * r * 2test(6.8)
test(10)
test(30)
问题: 代码重复

后期维护成本太高

代码可读性不高

解决问题：函数

在一个完整的项目中，某些功能会被反复使用，那么将这部分功能对应的代码提取出来，当需要使用功能的时候直接使用

本质：对一些特殊功能的封装

优点：

a.简化代码结构，提高应用的效率

b.提高代码复用性

c.提高代码的可读性和可维护性

建议：但凡涉及到功能，都尽量使用函数实现

1.2定义函数

语法：

def 函数名(参数1，参数2，参数3…):

函数体

返回值

说明：

a.函数由两部分组成：声明部分和实现部分

b.def,关键字，是define的缩写，表示定义的意思

c.函数名：类似于变量名，遵循标识符的命名规则，尽量做到顾名思义

d.（）：表示的参数列表的开始和结束

e.参数1，参数2，参数3… ：参数列表【形式参数，简称为形参】，其实本质上就是一个变量名，参数列表可以为空

f.函数体：封装的功能的代码

g.返回值：一般用于结束函数，可有可无，如果有返回值，则表示将相关的信息携带出去，携带给调用者，如果没有返回值，则相当于返回None

2.使用函数

2.1简单函数

无参无返回值的函数

代码演示：

#1.无参无返回值的函数
#函数的声明部分
def test():#函数的实现部分#函数体print("hello")

2.2函数的调用

定义好函数之后，让函数执行

格式：函数名(参数列表)

代码演示：

#print(num)
#test()#1.无参无返回值的函数
#函数的声明部分
def test():#函数的实现部分#函数体#print("hello")for i in range(10):print(i)def test():print("~~~~~~")#注意1：当定义好一个函数之后，这个函数不会自动执行函数体#2.函数的调用
#格式：函数名(参数列表)
#注意2：当调用函数的时候，参数列表需要和定义函数时候的参数列表保持一致
#注意3：一个函数可以被多次调用
test()
test()
test()
test()#3.注意4：当在同一个py文件中定义多个同名的函数，最终调用函数，调用的最后出现的函数【覆盖：函数名类似于变量名，相当于变量的重新赋值】
#4.注意5：自定义函数必须先定义，然后才调用，否则报NameError

函数的调用顺序：

#函数调用
#1.在一个自定义的函数内部也可以调用函数
#2.函数调用的顺序
def test1():print("aaaa")test2()print("over")def test2():print("bbbb")test3()test4()def test3():print("cccc")def test4():print("dddd")test1()#注意：函数在调用的过程中，相互之间的关系，以及代码执行的先后顺序

2.3函数中的参数

参数列表：如果函数所实现的功能涉及到未知项参与运算，此时就可以将未知项设置为参数

格式：参数1,参数2…

分类：

形式参数：在函数的声明部分，本质就是一个变量，用于接收实际参数的值【形参】

实际参数：在函数调用部分，实际参与运算的值，用于给形式参数赋值【实参】

传参：实际参数给形式参数赋值的过程，形式参数 = 实际参数

代码演示：
#传参：实际参数给形式参数赋值的过程，形式参数 = 实际参数#需求：给函数一个姓名和一个年龄，在函数内部将内容打印出来
def myPrint(name,age):print("姓名：%s,年龄：%d"%(name,age))#调用函数
str = "zhangsan"
num = 19
myPrint(str,num)"""
传参：
实参给形参赋值
name = "zhangsan"
age = 19
"""#需求：求两个数的和
def add(num1,num2):sum = num1 + num2print(sum)add(10,20)
add(33,2)#TypeError: add() missing 2 required positional arguments: 'num1' and 'num2'   实参和形参不匹配
形参和实参之间的关系：
#需求：交换两个变量的值
def exchange(num1,num2):temp = num1num1 = num2num2 = tempprint("exchange函数内部：num1=%d num2=%d"%(num1,num2))num1 = 11
num2 = 22
exchange(num1,num2)
print("外面：num1=%d num2=%d" % (num1, num2))#1.实参和形参重名对函数实现没有影响
#2.进行传参之后，实际参与运算的是形参，对实参没有影响【将形参可以理解为实参的替代品】
#3.本质原因：形参和实参在内存中开辟的空间不同

2.4值传递和引用传递【面试题】

值传递：传参的过程中传递的是值，一般指的是不可变的数据类型，number,tuple,string

引用传递：传参的过程中传递的是引用，一般指的是可变的数据类型，list，dict, set

代码演示：
#值传递
def func1(a):a = 10temp = 20
#传参：temp,但实际上传的是20
func1(temp)
print(temp)   #20#引用传递
def func2(list1):list1[0] = 100l = [10,20,30,40]
func2(l)    #list1 = l
print(l[0])"""
l = [10,20,30,40]
list1 = l
list1[0] = 100"""
总结：

引用传递本质上传递的是内存地址

2.5参数的类型【掌握】

a.必需参数

调用函数的时候必须以正确的顺序传参，传参的时候参数的数量和形参必须保持一致

代码演示：

#1.必需参数
def show1(str1,num1):print(str)show1("hello",10)
#show1()
#如果形参没有任何限制，则默认为必需参数，调用函数的时候则必需传参，顺序一致，数量一致

b.关键字参数

使用关键字参数允许函数调用的时候实参的顺序和形参的顺序可以不一致，可以使用关键字进行自动的匹配

代码演示：

#2.关键字参数
def show2(name,age):age += 1print(name,age)#正常调用
show2("abc",10)
#show2(10,"abc")#关键字参数调用函数
#注意1：关键字参数中的关键字其实就是形参的变量名，通过变量名进行传参
show2(age = 20,name = "lisi")
show2(name = "lisi",age = 20)#注意2：关键字参数只有一个的情况下，只能出现在参数列表的最后
show2("lisi",age = 30)#错误演示
#show2(40,name = "lisi")   TypeError: show2() got multiple values for argument 'name'
#show2(name = "lisi",40)#系统的关键字参数
print("",end=" ")

c.默认参数

调用函数的时候，如果没有传递参数，则会使用默认参数

代码演示：

#3.默认参数
#注意1：在形参设置默认参数，如果传参，则使用传进来的数据，如果不传参，则使用默认数据
def fun1(name,age=18):print(name,age)fun1("zhangsan",20)
fun1("lisi")
fun1(name = "abc",age = 33)
fun1(name = "hello")#注意2：在参数列表中，如果所有的形参都是默认参数，正常使用；但是，如果默认参数值只有一个，则只能出现在参数列表的最后面
def fun2(num1 = 10,num2 = 20):print(num1.num2)

d.不定长参数(可变参数)

可以处理比当初声明时候更多的参数 * **

代码演示：

#4.不定长参数【可变参数】
#4.1   *   ：被当做tuple处理，变量名其实就是一个元组名
#注意1：传参的时候，实参可以根据需求任意传参,数量不确定
#注意2:定义不定长参数时，最好将不定长参数放到参数列表的最后面【如果不定长参数出现在参数列表的前面，则在实参列表中使用关键字参数】
def func1(name,*hobby):print(name)print(hobby)print(type(hobby))   #<class 'tuple'>#遍历for element in hobby:print(element)func1("aaa","anc","aaa","5435","tesrg","gtsrhesh",10,True)# 4.2  **   :被当做字典处理，变量名就相当于字典名
def func2(**args):print(args)print(type(args))   #<class 'dict'>for k,v in args.items():print(k,v)#注意1：使用**的时候，实参就必须按照key=value的方式进行传参
func2(x = 10,y = 20)

2.6函数的返回值

作用：表示一个函数执行完毕之后得到的结果

使用:return,表示结束函数，将函数得到的结果返回给调用者

代码演示：

#1.结束函数，返回数据
#需求：求两个整数的和，并返回
def add(num1,num2):sum1 = num1 + num2#print(sum1)#将结果返回给调用者return sum1#注意：在同一个代码块中，如果在return后面出现语句，则永远不会被执行print("hello")#注意：如果一个函数由返回值，要么采用变量将返回值接出来，要么将整个函数的调用直接参与运算
r = add(10,20)
print(r)
print(add(10,20))   #30
#print("~~~~",sum1)total = add(1,2) + 5
print(total)    #8def func(num1,num2):sum2 = num1 + num2#注意：如果一个函数没有返回值，则整体计算的结果为None
#print(func(10,20))#如果一个函数没有返回值，则这个函数的调用不能直接参与运算
total1 = func(1,2) + 5  #TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
print(total1)

在分支语句中使用return

#2.如果一个函数体中有分支，设置了返回值，最好每一个分支都有一个返回值
#需求：输入两个数，比较两个数的大小，返回较大的一个
def compare(num1,num2):if num1 > num2:return num1elif num1 < num2:return num2else:return True,num1result = compare(12,12)
print(result)#注意1：在Python中，不同分支返回的数据类型可以是不相同的
#注意2;在Python中，一个return可以同时返回多个数据，被当做元组处理

总结：

自定义一个函数
是否需要设置参数：是否有未知项参与运算

是否需要设置返回值：是否需要在函数外面使用函数运算之后的结果

函数使用练习：

#需求1：封装函数功能，统计1~某个数范围内能被3整除的数的个数
"""
参数：某个数
返回值：可设置可不设置
"""
def getCount(num):count = 0for i in range(num + 1):if i % 3 == 0:count += 1#print(count)return countr1 = getCount(1000)
print(r1)
r2 = getCount(100)
print(r2)#需求2：封装函数功能，判断某年是否是闰年
"""
参数：某年
返回值：可设置可不设置
"""
def isLeapYear(year):if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:#print("闰年")#return "闰年"return  Trueelse:#print("平年")#return "平年"return Falseresult = isLeapYear(2020)
print(result)

3.匿名函数【掌握】

不再使用def这种的形式定义函数，使用lambda来创建匿名函数

特点：

a.lambda只是一个表达式，比普通函数简单

b.lambda一般情况下只会书写一行，包含参数，实现体，返回值

语法:lambda 参数列表：实现部分

代码演示：
#语法:lambda 参数列表 ： 实现部分#1.
#需求：求两个数的和
#普通函数
def add(num1,num2):sum = num1 + num2add(num1 = 10,num2 = 20)#匿名函数本身是没有函数名，将整个lambda表达式赋值给一个变量，然后将这个变量当做函数使用
sum1 = lambda n1,n2:n1 + n2
print(sum1(10,20))#2.在匿名函数中也可以使用关键字参数
g = lambda  x,y:x ** 2 + y ** 2
print(g(3,4))
print(g(x = 3,y = 4))#3.在匿名函数中也可以使用默认参数
h = lambda  x=0,y=0 : x ** 2 + y ** 2
print(h())
print(h(10))
print(h(10,20))

4.空函数和主函数

4.1空函数

一个什么都没有实现的函数

借助于pass语句

代码演示：
def func():pass

4.2主函数

每一个程序都有一个入口：主函数【main函数】

在Python中，主函数是隐式的

代码演示：
def show():print("hello")#通过__name__   == "__main__"表示其中的代码是在主函数中运行的
if  __name__  == "__main__":show()

Python 学习之路（上）相关推荐

python之路 mysql 博客园_教为学：Python学习之路（二）：MySQLdb的几种安装方式，以及用Python测试连接MySql...
教为学:Python学习之路(二):MySQLdb的几种安装方式,以及用Python测试连接MySql Easy_install安装MySQLdb 很简单,以至于我不晓得该怎么说.一句话. sodu ...
Python学习之路—2018/6/20
Python学习之路-2018/6/20 1.模板语法之变量 views.py def index(request):import datetimes="gyq"l=[1,2,3] ...
Python学习之路9☞面向对象的程序设计
Python学习之路9☞面向对象的程序设计一面向对象的程序设计的由来见概述:http://www.cnblogs.com/linhaifeng/articles/6428835.html 二什 ...
Python学习之路5☞文件处理
Python学习之路5☞文件处理一.文件处理流程打开文件,得到文件句柄并赋值给一个变量通过句柄对文件进行操作关闭文件 1 正趣果上果 2 Interesting fruit fruit 3 4 ...
python学习之路0x00
Python学习之路0x00 在学习python之前,要知道什么是python? python是一种跨平台的计算机程序设计语言.是一种面向对象的动态类型语言,与c语言不同, c语言要编译后才能执行.而 ...
我的Python学习之路（一）_Mr_Ouyang
我的Python学习之路(一)_Mr_Ouyang 笔者按: 本文从18:55开始写作,至19:38中断,又从21:12始继续,至23:22写就. 共计耗时113分钟,总字数9081字,约80.4字/ ...
python学习之路：python连接阿里云ODPS
python学习之路:python连接阿里云ODPS 前言本人最近在学习使用ODPS,希望把学习过程记录下来,方便自己查阅. 1.安装ODPS pip install ODPS 2.连接阿里云odp ...
Python学习之路【第一篇】-Python简介和基础入门
1.Python简介 1.1 Python是什么相信混迹IT界的很多朋友都知道,Python是近年来最火的一个热点,没有之一.从性质上来讲它和我们熟知的C.java.php等没有什么本质的区别,也是 ...
Python学习之路—2018/7/14
Python学习之路-2018/7/12 3.功能开发 3.3 设计博客首页博客首页中最重要的就是中间的文章区域,所以我首先把文章区域设计出来,一开始并没有数据,如果用orm添加或者直接在数据库添加 ...
python 学习之路开始了
python 学习之路开始了.....记录点点滴滴.... 转载于:https://www.cnblogs.com/chobit/p/6163287.html