1、简介

IDLE：写简单的代码，长代码需要新建文件来写

创建模板：
file-->settings-->Editor-->code style-->file an code temliates-->python scrip

2、print( ) 函数

作用：输出
可以输出的内容：数字 字符串 含有运算符发表达式
输出的目的地：显示器 文件
输出到文件：
fp=open('D:/text.txt','a+')

a+：如果文件不存在就创建，存在就在文件内容的后面继续追加

print('hello,world',file=fp)
fp.colse()

#print可以输出数字
print(520)
print(98.5)

#可以输出字符串
print('helloworld')
print("helloworld")

#含有运算符的表达式
print(3+1)

#输出到文件
#注意点：1.所指定的盘符存在，2.使用file=fp,缺少时文字写不进去文件
fp=open('D:/text.txt','a+')
#a+"如果文件不存在就创建一个，存在就在文件内容后面继续追加
print('helloworld',file=fp)
fp.close()

#不进行换行输出（输出内容在一行）
print('hello','world','Python')

3、转义字符

转义字符：就是反斜杠+想要实现的转移功能首字母
反斜线：\
单引号：'
双引号：\“
换行：\n
删除前面的代码：\r
空格：\t
退格：\b

原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加r或R
print(r'hello\nworld')

#转义字符
print('hello\nworld')#换行
print('hello\tworld')#空格
print('hello\rworld')#删除前面的代码
print('hello\bworld')#退一格，将o退没了

print('http:\ \ baidu.com')
print('老师说：'大家好'')

#原字符
print(r'hello\tworld')
#注意事项：最后一个字符不能是反斜线
#错误：print(r'heello\tworld')

4、标识符和保留字

保留字：有一些单词被赋予了特定的意义，这些单词在给你的任何对象起名字的时候都不能用

标识符：变量、函数、类、模块和其他对象的起的名字就叫标识符
规则：
字母、数字、下划线
不能以数字开头
不能是保留字
严格区分大小写

#保留字
import keyword
print(keyword.kwlist)

5、变量

name='玛丽亚'
name:变量
=：赋值运算符：
玛丽亚：值

变量由三部分组成：
标识：表示对象所存储的内存地址，使用内置函数id(obj)获取
类型：表示的是对象的数据，使用内置函数type(obj)获取
值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出
标识：id（）
类型：type（）
值：print（）

name='玛丽亚'
print("标识",id(name))
print("类型",type(name))
print("值",name)
--------------------
标识 1658444944848
类型 <class 'str'>
值 玛丽亚

当多次赋值之后，变量名会指向新的空间

name='玛丽亚'
name='楚留冰'
print('标识',id(name))
print('类型',type(name))
print('值',name)
-------------------
标识 2336450561104
类型 <class 'str'>
值 楚留冰

6、数据类型

整数类型：int 98
浮点型：float 3.1415926
布尔类型:bool true false
字符串类似:str ‘ ’ ""

整数类型
默认为十进制

n1=90
n2=-76
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可以表示为二进制 十进制 八进制 十六进制
print('十进制',178)#默认为十进制
print('二进制',0b10101111)#二进制以0b开头
print('八进制',0o76)#八进制以0o开头
print('十六进制',0x1EAF)#十六进制以0x开头

浮点类型
浮点数存储不精确，使用浮点数进行计算时，可能会出现小数位数不确定的情况
解决方案：导入模块decimal
from decimal import Decimal

#计算浮点型数据
n1=1.1
n2=2.2
print(n1+n2)
------------
3.3000000000000003
以上错误
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
---------
3.3

布尔类型
用来表示真或假的值
True表示真，False表示假
布尔值可以转化为整数
True->1
Flase->0

f1=True
f2=False
print(f1,type(f1))
print(f1,type(f2))

#布尔值可以转成整数计算
print(f1+1)
print(f2+1)

字符串类型
字符串又被称为不可变的字符序列
可以使用单引号‘ 双引号“ 三引号“““ 来定义
单引号和双引号定义的字符串必须在一行
三引号定义的字符串可以分布在连续的多行

str1='人生苦短'
str2="人生苦短"
str3="""人生
苦短"""
str4='''人生
苦短'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

7、数据类型转换

int --> str
用法：
str() 将其他类型的数据转成str类型

#int->str
name="张三"
age=20
print("我叫"+name+"我今年"+age)#当将str类型和int类型连接时，数据类型不同，会报错
-------------------------------
print("我叫"+name+"我今年"+age)
TypeError: can only concatenate str (not "int") to str

print("我叫"+name+"我今年"+str(age))

类似，转换类型的函数有：
str（）将其他类型的数据转成str类型
int（）将其他类型的数据转成int类型
float（）将其他类型的数据转成float类型

print("--------------int()")
s1='128'
f1=98.7
s2='76.77'
ff=True
s3='hello'
print(int(s1),type(int(s1))) #将str类型转成int类型，字符串为数字串
print(int(f1),type(int(f1))) #将float类型转成int类型，截取整数部分，舍掉小数部分
print(int(s2),type(int(s2))) #将str转成int类型，报错，因为字符串为小数
print(int(ff),type(int(ff))) #将bool转成数字
print(int(s3),type(int(s3))) #将str类型转成int类型时，字符串必须为数字串（整数数字）
-------------------------------------------------
ValueError: invalid literal for int() with base 10: '76.77'
ValueError: invalid literal for int() with base 10: 'hello'

print('-------float()')
s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
print(float(s3),type(float(s3))) #字符串中的数据如果是非数字串，则不允许转换
print(float(i),type(float(i)))
------------------------------------------
128.98 <class 'float'>
76.0 <class 'float'>
1.0 <class 'float'>
ValueError: could not convert string to float: 'hello'
98.0 <class 'float'>

8、注释

单行注释：以#开头，直到换行结束
多行注释：‘’‘ ’‘’
并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式
#coding:gbk 或者 #coding:utf-8

9、input（）函数

作用：接收用户的输入，类型为str类型

用法：
present=input（ ） #present 变量名

present=input("大圣想要什么礼物呢？")
print(present)
--------------------------
大圣想要什么礼物呢？金箍棒
金箍棒

#从键盘录入两个整数，将两个整数相加
a=int(input("请输入第一个数字"))
b=int(input("请输入第二个数字"))
print(a+b)

10、运算符

算术运算符：
标准运算符：+ - * / // （整数运算，一正一负向下取整）
取余运算符：%（余数=被除数-除数商 9%-4 9-（-4）（-3））
幂运算符：**
2**3=8 （222）

赋值运算符： = 运算顺序：从右到左
支持链式赋值： a=b=c=20
支持参数赋值： += -= *= /= //= %=
支持系列解包赋值： a,b,c=20,30,40

a=b=c=20#链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
----------------------
20 1811808807792
20 1811808807792
20 1811808807792

#参数赋值
a=20
a+=30#相当于a=a+30
print(a) #a=50

#交换两个变量的值
a,b=10,20
a,b=b,a
print(a,b)
------------------
20 10

比较运算符： 结果为bool类型

< >= <= !=
== 对象值 value的比较（ = 称为赋值运算符，== 称为比较运算符 相等的意思）
is is not 对象id的比较

a,b,c=10,20,10
#比较值 value
print('a>b吗?',a>b) #False
print('a<b吗?',a<b) #True
print('a>=b吗?',a>=b)#True
print('a<=b吗?',a<=b)#False
print('a==b吗?',a==b)#False
print('a!=b吗?',a!=b)#True
#比较id
print(a is b)#False
print(a is not b)#True
print(a is c)#True

布尔运算符：
and ：当两个运算数都为True时，运算结果才为True
or ：只要有一个运算数为True，运算结果就为True
not ：如果运算数为True，运算结果为False
如果运算数为False，运算结果为True
in ：判断字符是否在....里
not in ：判断字符是否不在....里

#布尔运算
#and
a,b=1,2
print(a==1 and b==2) #True True and True-->True
print(a==1 and b<2) #False True and False-->False
print(a!=1 and b==2) #False False and True-->False
print(a!=1 and b!=2) #False False and False-->False

#or
print(a==1 or b==2) #True True or True-->True
print(a==1 or b<2) #True True or False-->True
print(a!=1 or b==2) #True False or True-->True
print(a!=1 or b!=2) #False False or False-->False

#not
f1=True
f2=False
print(not f1) #False not True-->False
print(not f2) #True not False-->True

#in not in
s='hello'
print('h' in s) #True
print('k' in s) #False
print('h' not in s) #False
print('k' not in s) #True

位运算符： 将数据转成二进制进行计算
位与& 对应位数都是1，结果位数才是1，否则为0
位或| 对应位数都是0，结果位数才是0，否则为1
左移位运算符<< 高位溢出舍弃，低位补0
右移位运算符>> 低位溢出舍弃，高位补0

0 0 0 0 0 1 0 0 4的二进制
0 0 0 0 1 0 0 0 8的二进制
0 0 0 0 0 0 0 0 4&8的结果为0
0 0 0 0 1 1 0 0 4|8的结果为12
高位溢出
0 0 0 0 0 1 0 0 0 4<<1的结果为8 （左移一位相当于乘2）
低位补0

print(4&8)
print(4|8)
print(4<<1)
print(4<<2)
print(4>>1)
---------------
0
12
8
16
2

运算符的优先级 ：有括号的先计算括号里面的
算数运算符 (** * / // % + -)
->位运算符 (<< >> & | )
->比较运算符 (> < >= <= == != )
->布尔运算符( and or )
->赋值运算符(=)

程序的组织结构

计算机的流程控制：
顺序结构 选择结构 循环结构

顺序结构

顺序结构： 程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直到程序结束

选择结构

对象的布尔值：
Python一切皆为对象，所有对象都有一个布尔值
获取对象的布尔值： bool( )

以下对象的布尔值为False
False 数值（） None 空字符串 空列表 空元组 空字典 空集合

#以下对象的布尔值为False
print(bool(False)) #False
print(bool(0)) #数值0
print(bool(0.0))#数值0
print(bool(None))#None
print(bool(''))#空字符串
print(bool(""))#空字符串
print(bool([])) #空列表
print(bool(list()))#空列表
print(bool(())) #空元组
print(bool(tuple()))#空元组
print(bool({}))#空字典
print(bool(dict()))#空字典
print(bool(set()))#空集合

选择结构：程序根据判断条件的布尔值选择性地执行部分代码

单分支结构：
if 条件表达式:
条件执行体

money=1000 #余额
s=int(input('请输入取款金额')) #取款金额
#判断余额是否充足
if money>=s:
money= money-s
print('取款成功，余额为：',money)

双分支结构：
if 条件表达式:
条件执行体1
else：
条件执行体2

#从键盘录入一个整数，编写程序判断是奇数还是偶数
num=int(input('请输入一个整数'))
#条件判断
if num%2==0:
print((num,'是偶数'))
else:
print(num,'是奇数')

多分支结构：
if 条件表达式1：
条件执行体1
elif 条件表达式2：
条件执行体2
elif 条件表达式N：
条件执行体N
[else:] （方括号里面的内容可写可不写）
条件执行体N+1

#从键盘录入一个整数作为成绩，判断成绩的等级
'''
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或者大于100 显示输入错误
'''
score=int(input('请输入成绩'))
if score>=90 and score<=100:
print('A')
elif score>=80 and score<=89:
print('B')
elif score>=70 and score<=79:
print('C')
elif score>=60 and score<=69:
print('D')
elif score>=0 and score<=59:
print('E')
else:
print('输入错误')

Python特有的写法： 90<score<=100

score=int(input('请输入成绩'))
if 90<=score<=100:
print('A')
elif 80<=score<=89:
print('B')
elif 70<=score<=79:
print('C')
elif 60<=score<=69:
print('D')
elif s0<=score<=59:
print('E')
else:
print('输入错误')

嵌套if：
if 条件表达式1：
if 内层条件表达式：
内存条件执行体1
else：
内存条件执行体2
else：
条件执行体

'''
会员>=200 8折

=100 9折
非会员 >=200 9.5折
'''
answer=input('是会员吗？Y/N')
money=float(input('输入金额'))
#外层判断是否是会员
if answer=='Y':
if money>=200:
print('打8折，付款金额为：',money0.8)
elif money>=100:
print('打9折，付款金额为：',money0.9)
else:
print('不打折，付款金额为：',money)
else:#非会员
if money>=200:
print('打9.5折，付款金额为：',money*0.95)
else:
print('不打折，付款金额为:',money)

条件表达式：条件表达式是if else 的简写
语法结构：
(x) if 判断条件 else (y)
运算规则：
如果判断条件的布尔值为True，条件表达式返回值为x，否则条件表达式的返回值
为y

#判断两个整数的大小
num1=int(input('输入第一个数'))
num2=int(input('输入第二个数'))
#只有字符串才可以用连接符号+
print((str(num1)+'大于等于'+str(num2)) if num1>=num2 else (str(num1)+'小于'+str(num2)))

pass语句：
pass语句什么都不做，只是一个占位符，用在语法上需要语句的地方

什么时候使用：
先搭建语法结构，还没想好代码怎么写的时候

哪些语句一起使用：
if语句的条件执行体
for-in语句的循环体
定义函数时的函数体

answer=input('您是会员吗？Y/N')
#判断是否是会员
if answer=='Y':
pass
else:
pass

内置函数range()

range（）函数：
用于生成一个整数序列

创建range对象的三种方式：
range(stop) 创建一个[0,stop]之间的整数序列，步长为1
range(start,stop) 创建一个[start,stop)之间的整数序列，步长为1
range(start,stop,step) 创建一个[start,stop)之间的整数序列，步长为step

返回值是一个迭代器对象

range类型的优点：
不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的
因为仅仅需要存储start,stop,step，只有当用到range对象时，才会计算序列中的相关
元素

in与not in 判断整数序列中是否存在（不存在）指定的数

#range（）的三种创建方式
#第一种 range(终止值)
r1=range(10)#默认从0开始，步长为1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(r1) #range(0, 10)
print(list(r1)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 用于查看range对象中的整数序列
#list是列表的意思
#第二种 range(起始值，终止值）
r2=range(1,9) #指定了起始值，终止值，默认步长为1
print(list(r2)) #[1, 2, 3, 4, 5, 6, 7, 8]
#第三种 range(起始值，终止值，步长）
r3=range(3,9,2) #指定了起始值，终止值，步长
print(list(r3)) #[3, 5, 7]
#判断指定的整数是否在序列中
print(9 in r1) #True
print(11 in r1)#False
print(9 not in r1)#False
print(11 not in r1)#True

15.循环结构

while循环：
while 条件表达式：
条件执行体（循环体）

四步循环法：
初始化变量
条件判断
条件执行体（循环体）
改变变量

#计算1-100之间的偶数和
sum=0
a=1
while a<=100:
if a%2==0:
sum+=a
a+=1
print(sum)

for-in循环：
in表式从（字符串、序列等）中依次取值，又称遍历
for-in遍历的对象必须是可迭代的对象

语法结构：
for 自定义的变量 in 可迭代的对象：
循环体

循环体内不需要访问自定义变量，可以将自定义变量代替为下划线_

for item in 'python':
print(item)
----------------------
p
y
t
h
o
n

for i in range(5):
print(i)
-------------------------
0
1
2
3
4

#如果在循环体中不需要使用到自定义变量，可以下划线_代替
for _ in range(5):
print('python')
-----------------------------
python
python
python
python
python

#使用for循环计算1-100之间的偶数和
sum=0
for i in range(1,101,1):
if i%2==0:
sum+=i
print(sum)
-----------
2550

#输出100-999之间的水仙花数
'''
153=111+555+333
'''
for i in range(100,1000,1):
ge=i%10
shi=i//10%10
bai=i//100
if ge3+shi3+bai**3==i:
print(i)
----------------------
153
370
371
407

16.流程控制语句break

break：用于结束循环结构，通常与分支结构if一起使用

#从键盘输入密码，最多输入三次
for item in range(3):
pwd=input('输入密码')
if pwd=='8888':
print('密码正确')
break
else:
print('密码错误，重新输入')

#while循环
a=0
while a<3:
pwd=(input('输入密码'))
if pwd=='8888':
print('密码正确')
break
else:
print('密码错误，重新输入')
a+=1

流程控制语句continue语句

continue：用于结束当前循环，进入下一次循环，通常与分支结构if一起使用

#打印1-50中5的倍数
for item in range(1,51):
if item%5!=0:
continue
else:
print(item)

else语句

else的搭配：
if....else if条件表达式不成立时执行else
while.....else 没有碰到break时执行else
for....else 没有碰到break时执行else

for item in range(3):
pwd=input('请输入密码')
if pwd=='8888':
print('密码正确')
break
else:
print('密码错误')
else:
print('三次均输入错误')
-------------------------
请输入密码12
密码错误
请输入密码12
密码错误
请输入密码12
密码错误
三次均输入错误

19.嵌套循环

循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行

#输出三行四列
for i in range(3):
for j in range(4):
print('*',end='\t') #不换行
#如果没有end=‘ ’，每次print语句都会自动换行，

而有了这个语句，数据就不会自动换行，

而是在输出的数据后面加上空格

（空格数取决于引号里面的空格数）。

print()#换行
-------------------------

---

---

---

for i in range(9):#9行
for j in range(1,i+2):
print('*',end=' ')
print()
--------------------
*

---

---

---

---

---

---

---

for i in range(1,10):#行数
for j in range(1,i+1):
print(i,'',j,'=',ij,end='\t')#\t空格
print()#换行
----------------------
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

20.二重循环中的break与continue

二重循环中的break与continue用于控制本层循环

列表

变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，
程序可以方便地对这些数据进行整体操作

lst=['a',3,3.4]
print(lst)

列表的创建：
列表需要使用中括号[ ] ，元素之间使用逗号进行分隔
列表的创建方式：
使用中括号 lst=['a',1.1.2]
调用内置函数list（） lst=list(['a',1,1.2])

列表的特点：
列表元素按顺序有序排序
索引映射唯一一个数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存

#索引映射唯一一个数据
lst1=['a',3,3.4]
print(lst1[0])
-----------------------
a

列表元素的查询操作：
获取列表中指定元素的索引 index（ ）
查询格式：lst.index( )
如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
如果查询的元素在列表中不存在，则会抛出ValueError
还可以在指定的start和stop之间进行查找
获取列表中的单个元素
正向索引从0到N-1 举例：lst[0]
逆向索引从-N到-1 举例：lst[-N]
指定索引不存在，抛出IndexError
获取列表中的多个元素（切片）
列表名[start ：stop ：step]
step为正数：从start开始往后计算切片
step为负数：从start开始往前计算切片
切片会产生一个新列表
判断指定元素是否在列表中
元素 in 列表名
元素 not in 列表名
列表元素的遍历
for 迭代变量 in 列表名 ：

lst1=['a',3,3.4,'a']
print(lst1.index('a'))#0 如果列表中有相同的元素，只返回列表中相同元素的第一个元素
print(lst1.index('p'))#ValueError: 'p' is not in list
print(lst1.index('a',1,3))#在索引1-3中查找a ValueError: 'a' is not in list
print(lst1.index('a',0,2))#0
----------------------------
0
0

lst1=['a',3,3.4,'a']
#获取索引为1的元素
print(lst1[1])
#获取索引为-2的元素
print(lst1[-2])
#获取索引为5的元素
print(lst1[5])# 指定索引不存在，抛出IndexError IndexError: list index out of range
---------------------
3
3.4

lst1=[10,20,30,40,50,60,70,80,90]
print(id(lst1))#id:2461307835072
lst2=lst1[1:6:1]#切出来的是新的一个列表
print(lst2)
print(id(lst2))#id:2425419796992
print(lst1[6:1:-1])
-------------------------
2231102214912
[20, 30, 40, 50, 60]
2231102214656
[70, 60, 50, 40, 30]

lst=[1,2,2,3,1,4]
print(1 in lst)#True
print(9 in lst)#False
print(1 not in lst)#False
print(9 not in lst)#True
#遍历列表
for item in lst:
print(item)

列表元素的增加操作
列表名.append( ) 在列表的末尾添加一个元素
列表名.extend( ) 在列表的末尾至少添加一个元素
列表名.insert( ) 在列表的任意位置添加一个元素
切片 在列表的任意位置至少添加一个元素

#在列表的末尾添加一个元素
lst=[1,2,3]
lst.append(100)
print(lst) #[1, 2, 3, 100] 列表的Id不变
lst2=['a','b','c']
lst.append(lst2)#将lst2作为一个元素添加 [1, 2, 3, 100, ['a', 'b', 'c']]
print(lst)
#在列表的末尾添加两个元素
lst3=['A','B']
lst.extend(lst3) #[1, 2, 3, 100, ['a', 'b', 'c'], 'A', 'B']
print(lst)
#在列表的任意位置添加一个元素
lst.insert(1,'X')#在索引为1的位置添加X [1, 'X', 2, 3, 100, ['a', 'b', 'c'], 'A', 'B']
print(lst)
#在列表的任意位置上添加三个元素
lst4=[True,False,'hello']
lst[1::]=lst4#将lst4的元素赋值给lat[1::] [1, True, False, 'hello']
print(lst)

列表元素的删除操作
列表名.remove( ) 一次删除一个元素
重复元素只删除第一个
元素不存在抛出ValueError
列表名.pop( ) 删除一个指定索引位置上的元素
指定索引不存在抛出IndexError
不指定索引，删除列表中最后一个元素
切片 一次至少删除一个元素
切片会产生新列表，若不想产生新列表，则将切片后的列表赋值为空列表
列表名.clear( ) 清空列表
列表名.del 删除列表

lst=[10,20,30,40,50,30]
#remove
lst.remove(30)#从列表中移除一个元素，如果有重复元素只移除第一个 [10, 20, 40, 50, 30]
print(lst)
#pop 根据索引移除元素
lst.pop(1)#移除索引为1的元素 [10, 40, 50, 30]
print(lst)
#切片，删除至少一个元素 会产生一个新列表
lst2=lst[1:4:1]#[40, 50, 30]
print(lst2)
#不产生新的列表，而是删除原来的列表
lst[1:4:1]=[] #将切片后的列表替换为空列表 [10]
print(lst)
#clear
lst.clear()
print(lst) #[]
#del
del lst
print(lst) #name 'lst' is not defined

列表元素的修改操作
为指定索引的元素赋予一个新值
为指定的切片赋予一个新值

lst=[1,2,3]
#修改指定索引的值
lst[0]='a'# 修改索引为0的值为a ['a', 2, 3]
print(lst)
#修改多个元素的值
lst[0:2:1]=['x','y']#['x', 'y', 3]
print(lst)

列表的排序操作
列表名.sort()，列表中的所有元素默认按照从小到大的顺序进行排序，可以
指定reverse=True来进行降序排序
调用内置函数sorted()，可以指定reverse=True进行降序排序，会产生新列表，
原列表不发生改变

lst=[20,40,30,90,100,55]
#sort() 升序
lst.sort()#[20, 30, 40, 55, 90, 100]
print(lst)
#sort() 降序
lst.sort(reverse=True)#reverse=True 表示降序排序 [100, 90, 55, 40, 30, 20]
print(lst)
lst.sort(reverse=False)#reverse=False 表示升序排序 [20, 30, 40, 55, 90, 100]
print(lst)
#sorted() 升序 产生一个新的列表
lst2=sorted(lst)#[20, 30, 40, 55, 90, 100]
print(lst2)
#sorted() 降序 产生一个新的列表
lst3=sorted(lst,reverse=True)#[100, 90, 55, 40, 30, 20]
print(lst3)

列表生成式
列表生成式简称“生成列表的公式”
语法：
[ ii for i in range() ]
ii ：表示列表元素的和i相关的表达式，元素显示的值就是表达式的值
i：自定义变量
range()：可迭代对象

lst=[ii for i in range(1,10)]
print(lst)#[1, 4, 9, 16, 25, 36, 49, 64, 81]
lst2=[i3 for i in range(1,10)]
print(lst2)#[3, 6, 9, 12, 15, 18, 21, 24, 27]

22.字典

字典：
Python内置的数据结构之一，与列表一样式一个可变序列
以键值对的方式存储数据，字典是一个无序的序列
键必须是一个不可变序列，如字符串和整数

字典的创建：
使用花括号：
scores={ '张三':100，'李四'：98，'王五'：45}
scores:字典名
张三：键
100：值
使用内置函数dict()
dict(name='jack',age=20)
name：键
jack：值

#使用{}创建字典
scores={'张三':100,'李四':98,'王五':78}
print(scores)#{'张三': 100, '李四': 98, '王五': 78}
#使用内置函数dict
student=dict(name='张三',age=30)
print(student)#{'name': '张三', 'age': 30}
#空字典
d={}

字典的实现原理
Python中的字典是根据key（键）查找value所在的位置

字典中元素的获取
[] 举例：scores['张三']
get()方法 举例：scores.get('张三')
[]如果字典中不存在指定的key，抛出keyError异常
get()方法取值，足够字典中不存在指定的key，并不会抛出keyError
而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

scores={'张三':100}
#使用[]获取
print(scores['张三'])#100
print(scores['李四'])#KeyError: '李四'
#使用get()
print(scores.get('张三'))#100
print(scores.get('李四'))#None
print(scores.get('王五',99))#99
#99是在查找'王五'所对应的value不存在时，提供的一个默认值

key的判断
in 指定的key在字典中存在返回True
not in 指定的key在字典中不存在返回True

字典元素的删除
del scores['张三']

字典元素的新增
scores['jack']=90

字典元素的修改
scores['jack']=70

scores={'张三':100,'李四':89,'王五':67}
#key的判断
print('张三' in scores)#True
print('张三' not in scores)#False
#删除元素
del scores['张三']
print(scores)#{'李四': 89, '王五': 67}
#添加元素
scores['陈六']=45
print(scores)#{'李四': 89, '王五': 67, '陈六': 45}
#更改元素
scores['陈六']=99#{'李四': 89, '王五': 67, '陈六': 99}
print(scores)

字典的视图操作
获取字典视图的三个方法
字典名.keys() 获取字典中所有的key
字典名.values() 获取字典中所有的value
字典名.items() 获取字典中所有的key,value对

scores={'张三':90,'李四':30,'王五':89}
#获取所有的key
keys=scores.keys()
print(keys)#dict_keys(['张三', '李四', '王五'])
print(type(keys))#<class 'dict_keys'>
print(list(keys))#将所有的key组成的视图转成列表 ['张三', '李四', '王五']
#获取所有的value
values=scores.values()
print(values)#dict_values([90, 30, 89])
print(type(values))#<class 'dict_values'>
print(list(values))#将所有的value组成的视图转成列表 [90, 30, 89]
#获取所有的key,values对
items=scores.items()
print(items)#dict_items([('张三', 90), ('李四', 30), ('王五', 89)])
print(type(items))#<class 'dict_items'>
print(list(items))# 转换之后的列表元素由元组组成 [('张三', 90), ('李四', 30), ('王五', 89)]

字典元素的遍历
for item in scores:
print(item)

scores={'张三':90,'李四':30,'王五':89}
for item in scores:
print(item)#输出的是所有元素的键
print(scores[item],scores.get(item))#获取元素的值

字典的特点
字典中所有的元素都是一个key-value对，key不允许重复，value可以重复
字典中的元素是无序的
字典中的key必须是不可变对象
字典也可以根据需要动态地伸缩
字典会浪费较大的内存。是一种使用空间换时间的数据结构

字典的生成式
内置函数zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后
返回由这些元组组成的列表
items=['Fruits','Books','Others']
prices=[96,78,85]
dicts=zip(items,prices)
print(list(dicts))
字典生成式
{item:price for item,price in zip(items,prices)}
item 表示字典key的表达式
price 表示字典value的表达式
item price 自定义表示key value的变量
zip(items,prices) 可迭代对象

items=['Fruits','Books','Others']
prices=[96,78,85]
d={item:price for item,price in zip(items,prices)}
print(d)#{'Fruits': 96, 'Books': 78, 'Others': 85}

23.元组

元组
Python内置的数据结构之一，是一个不可变序列

不可变序列与可变序列
不可变序列：字符串 元组
没有增删改的操作
可变序列：列表 字典 集合
可以对序列执行增删改操作，对象地址不发生更改

元组的创建方式
直接使用小括号
t=('Python','hello',90)
使用内置函数tuple()
t=tuple(('Python','hello',90))
只包含一个元组的元素需要使用逗号和小括号
t=(10,)

#使用()创建元组
t1=('A','B',98)
print(t1)#('A', 'B', 98)
print(type(t1))#<class 'tuple'>
#使用内置函数tuple
t2=tuple(('S','D',87))
print(t2)#('S', 'D', 87)
#元组中只有一个元素,必须在元素后面加逗号
t3=('Q',)
t4=('W')
print(t3)#('Q',)
print(t4)#W
print(type(t3))#<class 'tuple'>
print(type(t4))#<class 'str'>
#空元组
tt=()
print(tt)#()

为什么将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁，因此，在程序中尽量使用不可变序列
注意事项：
元组存储的是对象的引用
如果元组中对象本身不可对象，则不能再引用其他对象
如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

获取元组的数据
元组名[索引]

t=(10,[20,30],'A')
print(t)#(10, [20, 30], 9)
print(type(t))#<class 'tuple'>
print(t[0],type(t[0]),id(t[0]))#10 <class 'int'> 1755092511280
print(t[1],type(t[1]),id(t[1]))#[20, 30] <class 'list'> 1755094258432
print(t[2],type(t[2]),id(t[2]))#A <class 'str'> 2734200439024

元组的遍历
元组是可迭代对象，所以可以使用for in 进行遍历
t=(10,[20,30],'A')
for i in t:
print(i)

#元组的遍历
t=('Python','hello',10)#Python
#第一种获取元组的方式，使用索引
print(t[0])
#第二种，遍历
for i in t:
print(i)#Python
#hello
#10

集合

集合：
是Python语言提供的内置数据结构
与列表，字典一样都属于可变类型的序列
集合是没有value的字典
集合中的元素不允许重复
集合是无序序列

集合的创建方式
使用{}创建
s={'Python','hello',90}
使用内置函数set()
s=set()

#集合的创建
#第一种{}
s={2,3,4,5,6,6,4}
print(s)#{2, 3, 4, 5, 6}
#第二种 set()
s1=set(range(6))#将整数序列转成集合类型
print(s1,type(s1))#{0, 1, 2, 3, 4, 5} <class 'set'>
s2=set([1,2,2,3])#将列表转成集合
print(s2,type(s2))#{1, 2, 3} <class 'set'>
s3=set((1,2,3,3))#将元组转成集合
s4=set('A')#将字符串转成集合
print(s4)#{'A'}
s5=set({1,2,3,4,4})#将字典转成集合
print(s5)#{1, 2, 3, 4}
#空集合
s6=set()
print(s6)#set()

集合元素的判断操作
in not in

集合元素的添加操作
调用 集合名.add() 方法，一次添加一个元素
调用 集合名.update() 方法，至少添加一个元素

集合元素的删除操作
调用 集合名.remove() 方法，一次删除一个指定元素，如果指定的元素不存在，抛出keyError异常
调用 集合名.discard() 方法，一次删除一个指定元素，如果指定元素不存在，不抛出异常
调用 集合名.pop() 方法，一次只删除一个任意元素
调用 集合名.clear() 方法，清空集合

s={1,2,3,'a'}
#判断元素是否在集合中
print(1 in s)#True
print(1 not in s)#False
#添加元素到集合
s.add(99)#添加一个元素99
print(s)
s.update({23,'q'})#添加集合元素
print(s)#{1, 2, 99, 3, 'q', 23, 'a'}
s.update([33,44])#添加列表
print(s)#{'a', 1, 2, 3, 99, 33, 'q', 44, 23}
s.update((20,30))#添加元组
print(s)#{'a', 1, 2, 3, 99, 33, 'q', 44, 20, 23, 30}
#删除集合中的元素
s.remove('a')#删除指定元素,如果指定的元素不存在，抛出keyError异常
print(s)#{1, 2, 99, 3, 33, 44, 20, 23, 'q', 30}
s.discard('q')#一次删除一个指定元素，如果指定元素不存在，不抛出异常
print(s)#{1, 2, 99, 3, 33, 44, 20, 23, 30}
s.pop()#一次只删除一个任意元素
print(s)#{2, 99, 3, 33, 44, 20, 23, 30}
s.clear()#清空集合
print(s)#set() 空集合

集合间的关系
两个集合是否相等
可以使用运算符==或！=进行判断
一个集合是否是另一个集合的子集
调用方法issubset进行判断
一个集合是否是另一个集合的超集
调用方法issuperset进行判断
两个集合是否没有交集
调用方法isdisjoint进行判断

#两个集合是否相等 (元素相同，则相等）
s1={10,20,30,40}
s2={40,20,30,10}
print(s1==s2)#True
print(s1!=s2)#False
#一个集合是否为另一个集合的子集 issubset
s1={1,2,3,4}
s2={1,2,3,4,5}
s3={1,2,6,7,8,9}
s4={'a','b'}
print(s1.issubset(s2))#s1是否为s2的子集 True
print(s3.issubset(s2))#s3是否为s2的子集 False
#一个集合是否为另一个集合的超集 issuperset
print(s2.issuperset(s1))#s2是否为s1的超集 True
print(s3.issuperset(s2))#s3是否为s2的超集 False
#两个集合是否没有交集
print(s2.isdisjoint(s3))#s2和s3没有交集 False 说明有交集
print(s4.isdisjoint(s3))#s4和s3没有交集 True

集合的数学操作
交集操作
s1.intersection(s2)
或者s1&s2
并集操作
s1.union(s2)
或者s1|s2
差集操作
s1.difference(s2)
对称差集
s1.symmetric_difference(s2)
或者s1^s2

集合生成式
用于生成集合的公式
{ ii for i in range(1,10)}
ii：表示集合元素的表达式
i:自定义变量
range(1,10)：可迭代对象

s={i**3 for i in range(1,10)}
print(s)#{64, 1, 512, 8, 343, 216, 729, 27, 125}

25.列表、字典、元组、集合的总结

数据结构 是否可变 是否重复 是否有序 定义符号

列表（list） 可变 可重复 有序 []
元组（tuple） 不可变 可重复 有序 ()
字典（dict） 可变 key不可重复，value可重复 无序 {key:value}
集合（set） 可变 不可重复 无序 {}

字符串

字符串的驻留机制
字符串
在Python中字符串是基本数据类型，是一个不可变的字符序列
字符串的驻留机制
仅保存一份相同且不可变字符串的方法 ，不同的值被存放在字符串的驻留池中，Python的驻留机制
会对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址
赋给新创建的变量
驻留机制的几种情况（交互模式）
字符串的长度为0或1时
符合标识符的字符串
字符串中在编译时进行驻留，而非运行时
[-5,256]之间的整数数字
sys中的intern方法强制2个字符串指向同一个对象
pyCharm对字符串进行了优化处理
字符串驻留机制的优缺点
1.当需要值相同的字符串时，可以之间从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和
节约内存，因此拼接字符串和修改字符串是比较影响性能的
2.在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为jion()方法时先计算出所有字符
中的长度，然后再拷贝，只new一次对象，效率要比+高

a='Python'
b="Python"
c='''Python'''
print(a,id(a))#Python 2750706178416
print(b,id(b))#Python 2750706178416
print(c,id(c))#Python 2750706178416

字符串的查询操作的操作方法
字符串名.index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，抛出ValueError
字符串名.rindex() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，抛出ValueError
字符串名.find() 查找子串substr第一次出现的位置，如果查找的子串不存在时，返回-1
字符串名.rfind() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，返回-1

s='hello,hello'
print(s.index('lo'))#3
print(s.rindex('lo'))#9
print(s.find('lo'))#3
print(s.rfind('lo'))#9

字符串的大小写转换的操作方法
字符串名.upper() 把字符串中所有字符都转成大写字母
字符串名.lower() 把字符串中所有字符都转成小写字母
字符串名.swapcase() 把字符串所有大写字母转成小写字母，所有小写字母转成大写字母
字符串名.capitalize() 把第一个字符转换成大写，其余字符转换成小写
字符串名.title() 把每个单词的第一个字符转成大写，把每个单词的剩余字符转换成小写

a='python'
A=a.upper()#转成大写之后，会产生新的字符串对象
print(A)#PYTHON
A='PYTHON'
a=A.lower()#转成小写之后，会产生新的字符串对象
print(a)#python
b='Python'
b1=b.swapcase()
print(b1)#pYTHON
c='pTHON'
c1=c.capitalize()
print(c1)#Pthon
d='hELLO,wORLD'
d1=d.title()
print(d1)#Hello,World

字符串内容对齐的操作方法
字符串名.center() 居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数时可选的
默认是空格，如果设置宽度小于实际宽度则返回原字符串
字符串名.ljust() 左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数时可选的
默认是空格，如果设置宽度小于实际宽度则返回原字符串
字符串名.rjust() 右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数时可选的
默认是空格，如果设置宽度小于实际宽度则返回原字符串
字符串名.zfill() 右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，
如果指定的宽度小于等于字符串的长度，返回字符串本身

s='hello,Python'
#居中对齐，第1个参数指定宽度，第2个参数指定填充符
print(s.center(20,''))#hello,Python
#左对齐，第1个参数指定宽度，第2个参数指定填充符
print(s.ljust(20,''))#hello,Python********
#右对齐，第1个参数指定宽度，第2个参数指定填充符
print(s.rjust(20,'*'))#********hello,Python
#右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度
print(s.zfill(20))#00000000hello,Python

字符串劈分操作的方法
字符串名.split() 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
以通过参数sep指定劈分字符串的劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数，再经过最大次劈分后，
剩余的子串会单独作为一部分
字符串名.rsplit() 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
以通过参数sep指定劈分字符串的劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数，再经过最大次劈分后，
剩余的子串会单独作为一部分

s='hello world Python'
#从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
lst=s.split()
print(lst)#['hello', 'world', 'Python']
#以通过参数sep指定劈分字符串的劈分符
s1='hello|world|Python'
lst1=s1.split(sep='|')
print(lst1)#['hello', 'world', 'Python']
#通过参数maxsplit指定劈分字符串时的最大劈分次数
print(s1.split(sep="|",maxsplit=1))# 最大分一次 ['hello', 'world|Python']
#从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
print(s.rsplit())#['hello', 'world', 'Python']
print(s1.rsplit(sep='|'))#['hello', 'world', 'Python']
print(s1.rsplit(sep='|',maxsplit=1))#['hello|world', 'Python']

判断字符串操作的方法
字符串名.isidentifier() 判断指定的字符串是不是合法的标识符（合法的标识符仅由数字，字母，下划线组成）
字符串名.isspace() 判断指定的字符串是否全部由空白字符组成（回车，换行，水平制表符）
字符串名.isalpha() 判断指定的字符串是否全部由字母组成
字符串名.isdecimal() 判断指定字符串是否全部由十进制的数字组成
字符串名.isnumeric() 判断指定的字符串是否全部由数字组成
字符串名.isalnum() 判断指定的字符串是否全部由字母和数字组成

s='hello,world'
#判断指定的字符串是不是合法的标识符（合法的标识符仅由数字，字母，下划线组成）
print(s.isidentifier())#False
print('hello_'.isidentifier())#True
print('张三_'.isidentifier())#True
#判断指定的字符串是否全部由空白字符组成（回车，换行，水平制表符）
print(s.isspace())#False
print('\t'.isspace())#True
#判断指定的字符串是否全部由字母组成
print(s.isalpha())#False
print('as'.isalpha())#True
#判断指定字符串是否全部由十进制的数字组成
print(s.isdecimal())#False
print('122'.isdecimal())#True
#判断指定的字符串是否全部由数字组成
print(s.isnumeric())#False
print('12323'.isnumeric())#True
#判断指定的字符串是否全部由字母和数字组成
print(s.isalnum())#False
print('123abc'.isalnum())#True

字符串的替换与合并的操作方法
字符串的替换
字符串名.replace() 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，
替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数
字符串的合并
要合并的字符串名.join() 将列表或元组中的字符串合并成一个字符串

s='hello,Python,Python,Python'
#替换
print(s.replace('Python','world'))#hello,world,world,world
print(s.replace('Python','world',2))#最多替换2次，hello,world,world,Python
#合并
#合并列表
lst=['h','e','l','l','o']
print('|'.join(lst))#h|e|l|l|o
print(''.join(lst))#hello
#合并元组
t=('P','y','t','h','o','n')
print('|'.join(t))#P|y|t|h|o|n

字符串的比较的操作方法
运算符

< >= <= == !=
比较规则
首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串
中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
比较原理
两个字符进行比较时，比较的时其ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value。
与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
==和is的区别
== 比较的是值是否相等
is 比较的是id是否相等

print('apple'>'app')#True
print('apple'>'banana')#False
#调用ord()获取原始值
print(ord('a'),ord('b'))#97 98
print(ord('张'))#24352
#调用chr()获取对应字符
print(chr(97),chr(98))#a b
print('apple'=='app')#False

字符串的切片的操作方法
字符串是不可变类型
字符串不具备增删改等操作
切片操作将产生新的对象

s='hello,python'
s1=s[:5]#由于没有指定起始位置，从0开始
s2=s[6:]#由于没有指定结束位置，切除到最后一位
s3=[s1,s2]
s4=s1+'!!'+s2
print('!'.join(s3))#hello!python
print(s4)#hello!!python

格式化字符串
%作为占位符
%s 字符串
%i或%d 整数
%f 浮点数
'我叫%s，今年%i岁' % (name,age)
{}作为占位符
'我叫{0}，今年{1}岁'.format(name,age)

name='张三'
age=10
#%作占位符
print('我叫%s，我今年%i岁' % (name,age))#我叫张三，我今年10岁
#{}作占位符
print('我叫{0}，我今年{1}岁'.format(name,age))#我叫张三，我今年10岁
#表示宽度
print('%10d' % 99)# 99
print('{0:10}'.format(99))# 99
print('{0:.3}'.format(3.1415926))#.3表示的是一共3位数 3.14
#表示精度
print('%.3f' % 3.1415926)#3.142
print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数 3.142
#同时表示宽度和精度
print('%10.3f' % 3.1415926)# 3.142
print('{0:10.3f}'.format(3.1415926))# 3.142

字符串的编码转换
A计算机——>编码——>byte字节传输——>解码——>B计算机
编码
将字符串转换为二进制数据（bytes）
解码
将bytes类型的数据转换成字符串类型

s='天涯'
#编码
print(s.encode(encoding='GBK'))#在GBK这种编码格式中，一个中文占两个字节

b'\xcc\xec\xd1\xc4'

print(s.encode(encoding='UTF-8'))#在UTF-8这种编码格式中，一个中文占三个字节
#b'\xe5\xa4\xa9\xe6\xb6\xaf'
#解码
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))#天涯

27.函数

函数：
函数就是执行特定任务完成特定功能的一段代码
函数的优点：
复用代码
隐藏实现细节
提高可维护性
提高可读性便于调试
函数的创建
def 函数名([输入参数]):
函数体
[return xxx]
例子：
def calc(a,b):
c=a+b
return c
函数的调用
函数名([实际参数])
例子：
result=calc(10,20)
print(result)
函数的参数传递
函数调用的参数传递
位置实参
根据形参对应的位置进行实参传递
例子：
result=calc(10,20)
print(result)
关键字实参
根据形参名称进行实参传递
例子：
result=calc(b=10,a=20)
print(result)
在函数调用过程中，进行参数的传递，如果是不可变对象，在函数体的修改不会影响实参的值，
如果是可变对象，在函数体内的修改会影响实参的值

def fun(arg1,arg2):
print('arg1',arg1)
print('arg2',arg2)
arg1=100
arg2.append(10)
print('arg1',arg1)
print('arg2',arg2)

----------------

n1=11
n2=[22,33,44]
print('进入函数前n1',n1)
print('进入函数前n2',n2)
fun(n1,n2)#位置传参，arg1 arg2是函数定义处的形参，n1 n2是函数调用处的实参
#实参名称和形参名称可以不一致
print('进入函数后n1',n1)#进入函数后n1 11
print('进入函数后n2',n2)#进入函数后n2 [22, 33, 44, 10]

函数的返回值
函数的返回值如果是一个值，直接返回类型
函数的返回值如果是多个值时，结果为元组
如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据），return可以不写

def fun(num):
odd=[] #存奇数
even=[]#存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))#([29, 23, 53, 55], [10, 34, 44])

函数的参数定义
函数定义默认值参数
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def fun(a,b=10):
print(a,b)
#函数的调用
fun(100)#采实参与形参的默认值相符 采用形参 100 10
fun(10,30)# 实参与形参的默认值不符，采用实参 10 30

个数可变的位置参数
定义函数时，无法事先确定传递的位置实参的个数时，使用可变的位置形参
个数可变的位置参数只能是一个
使用*定义个数可变的位置形参
结果为一个元组
个数可变的关键字形参
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
个数可变的关键字参数只能是一个
使用**定义个数可变的关键字形参
结果为一个字典
在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求个数可变的位置形参
放在个数可变的关键字形参之前(*args.**args)

#函数定义时，个数可变的位置参数
def fun(*args):
print(args)
#函数调用
fun(10)#(10,)
fun(12,13)#(12, 13)
fun(30,40,50)#(30, 40, 50)
#函数定义时，个数可变的关键字参数
def fun1(**argss):
print(argss)
#函数调用
fun1(a=10)#{'a': 10}
fun1(a=10,b=20,c=30)#{'a': 10, 'b': 20, 'c': 30}

函数的参数总结
参数的类型 函数的定义 函数的调用 备注
----------------------------------------------------------------------------------------------
位置实参 √
将序列中的每个元素都转换为位置实参 √ 使用*
关键字实参 √
将字典中的每个键值对都转换为关键字实参 √ 使用**
默认值形参 √
关键字形参 √ 使用*
个数可变的位置形参 √ 使用*
个数可变的关键字形参 √ 使用**

#函数的定义
def fun(a,b,c):#a,b,c在函数的定义处，所有是形式参数
print('a=',a)
print('b=', b)
print('c=', c)
#函数的调用
fun(10,20,30)#函数调用时的参数传递，称为位置传参
lst=[11,22,33]
fun(lst)#在函数调用时，将列表中的每个元素都转换为位置实参传入
fun(a=100,b=200,c=300)#在函数的调用处，是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic)#在函数调用时，将字典中的键值对都转换为关键字实参传入
#函数的定义
def fun1(a,b=10):#b是在函数的定义处，所有b是形参，而且进行了赋值，所以b是默认值形参
print('a=',a)
print('b=',b)
def fun2(args):#个数可变的位置形参
print(args)
def fun3(**args2):#个数可变的关键字形参
print(args2)
#函数的调用
fun1(10)#a赋值为10,b采用默认值.b=10
fun1(10,100)#a赋值为10，b的实参和默认值不同，b采用实参，b=100
fun2(11,22,33)#个数可变的位置形参，输出结果为元组 (11, 22, 33)
fun3(a=111,b=222,c=333)#个数可变的关键字形参，输出结果为字典 {'a': 111, 'b': 222, 'c': 333}
#函数的定义
def fun4(a,b,,c,d):#从之后的参数，在函数调用时，只能采用关键字参数传递
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)
#函数的调用
fun4(10,20,c=30,d=40)#a，b采用位置实参传递。c,d采用关键字实参传递
fun4(a=11,b=22,c=33,d=44)#关键字实参传递

变量的作用域
程序代码能访问该变量的区域
根据变量的有效范围可分为
局部变量
在函数内定义并使用的变量，只在函数内部有效
局部变量使用global声明，这个变量就会成全局变量
全局变量
函数体外定义的变量，可作用于函数内外

def fun():
global age
age=20
#age是函数内部定义的变量，为局部变量，但当局部变量使用global声明时，这个局部变量会变成全局变量
print(age)
fun()#20
print(age)#20

递归函数
递归函数的定义
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
递归的组成部分
递归调用与递归终止条件
递归的调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应的空间
递归的优缺点
缺点：占用内存多，效率低下
优点：思路和代码简单

#计算阶乘
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
#调用
print(fac(6))#720

#斐波那契数列
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-2)+fib(n-1)
#第6位的数
print(fib(6))#8
#输出前6位
for i in range(1,7):
print(fib(i))

Bug

Bug的分类
粗心导致的错误
知识点不熟悉导致的错误
思路不清楚导致的错误
解决方案：
使用print()函数
使用#暂时注释部分代码
被动掉坑：程序代码逻辑没有错，只是因为用户错误或者一些“例外情况”导致的程序崩溃

29.Python的异常处理机制

Python提供了异常处理机制，可以在异常出现时及时捕获，然后内部“消化”，让程序继续运行

单个except
try:
可能会出现异常的代码
except 异常类型 :
异常处理代码
多个expect：捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseExcention
try:
可能会出现异常的代码
except 异常类型1 :
异常处理代码
except 异常类型2 :
异常处理代码
except 异常类型n :
异常处理代码
except BaseException:
异常处理代码
try...except...else结构：如果try块中没有出现异常，则执行else块，如果try块中有异常，则执行except块
try:
可能会出现异常的代码
except BaseException as 错误别名:
异常处理代码
else:

try:
a=int(input('输入第一个数字'))
b=int(input('输入第二个数字'))
result=a/b
except BaseException as e:
print('出错了',e)
else:
print('结果为',result)
-------------------------------------
输入第一个数字a
出错了 invalid literal for int() with base 10: 'a'

try...except...else...finally结构：finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源
try:
可能会出现异常的代码
except BaseException as 错误别名:
异常处理代码
else:
执行代码
finally:
执行代码

try:
a=int(input('输入第一个数字'))
b=int(input('输入第二个数字'))
result=a/b
except BaseException as e:
print('出错了',e)
else:
print('结果为',result)
finally:
print('谢谢使用')

常见的异常类型
ZeroDivisionError 除（或取模）零（所有数据）
IndexError 序列中没有此索引
KeyError 映射中没有这个键
NameError 未声明/初始化对象（没有属性）
SyntaxError Python语法错误
ValueError 传入无效的参数

traceback模块
使用traceback模块打印异常信息

import traceback
try:
print(1/0)
except:
traceback.print_exc()

Pycharm的程序调试