Python学习笔记——记录学习点滴

第一章

Print（）函数——功能

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

\#可以输出字符串
print('hello world!')
print("hello world !")

\#可以输出含有运算符的表达式
print("5+3")
print(5+3)

\#可以讲数据输出到文件中，注意点：1、路径中盘符要存在；2、文件file=fp；
fp=open('D:/学习资料/text.txt','a+')
print('helloworld',file=fp)
fp.close()

\#不进行换行输出，即仅仅在一行输出
print('I','can','do','it')

转义字符——\n \t \r \b \ \

# 开发时间：2022/3/30 11:32
\#转义字符
print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')#\t水平制表符
print('hello\rworld')#\r回车
print('hello\bworld')#\b退格

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

\#原字符，不希望字符串中的转义字符起作用，就使用原字符，就是字符串之前加上r，或R
print(r'hello\nworld')
\#注意事项，最后一个字符不能是反斜杠
print(r'hello\nworld')

知识点总结

Print()函数 功能：向目的地输出内容

​ 输出内容：数字、字符串、表达式

​ 目的地：IDLE、控制台、文件

转义字符的分类 常表示的字符	转义字符	备注
	换行	\n	newline光标移到下一行的开头
无法直接表示的字符	回车	\r	return光标移动到本行的开头
	水平制表符	\t	tab键，光标移动到下一组4个空格的开始处
	退格	\b	键盘上的backspace键，回退一个字符
在字符串中有特殊	反斜杆	\\
用途的字符	单引号	\’
	双引号	\"

第二章

二进制和字符编码

print(chr(0b100111001011000))
print(ord('乘'))

标识符和保留字

规则：

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

\# 开发时间：2022/3/31 9:54
import keyword
print(keyword.kwlist)

标识符和保留字：False、None、True、and、as、assert、break、class、continue、def、del、elif、else、except、finally、for、from、global、if、import、in、is、lambda、nonlocal、not、or、pass、raise、return、try、while、with、yield

变量的定义和使用

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

\# 开发时间：2022/3/31 10:10
name='玛利亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

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

  # 开发时间：2022/3/31 10:17
  name='玛利亚'
  print(name)
  name='楚留冰'
  print(name)

数据类型

• 常用的数据类型
  • 整数类型 int ：98
  • 浮点数类型 float：3.14159
  • 布尔类型：bool: True\False
  • 字符串类型：str:‘人生苦短，我用python’

数据类型

• 整数类型
  • 英文为integer，简写int，可以表示正数、负数和零
  • 正数的不同进制表示方式
    • 十进制 默认进制
    • 二进制 以0b开头
    • 八进制 以0o开头
    • 十六进制 以0x开头

#整型可以表示为正数、负数和零
n1=521
n2=0
n3=-1314
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可以表示为二进制、十进制、八进制和十六进制
print('二进制',0b10101011)  #二进制以0b开头
print('十进制',521)
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1EAF)#十六进制以0x开头

• 浮点类型

  • 浮点数整数部分和小数部分组成
  • 浮点数存储不精确性
    • 使用浮点数进行计算时，可能会出现小数位数不确定的情况

# 开发时间：2022/3/31 10:46
n1=1.1
print('类型',type(n1))
n2=2.2
print(n1+n2)
n3=2.1
print(n1+n3)  #不精确

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))  #3.3

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

# 开发时间：2022/3/31 11:14
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))

#布尔值可以转成整数计算
print(f1+0)  #1    1+0的结果为1，True表示1
print(f2+0)  #0    0+0的结果为0，False表示0

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

str1="人生苦短，我用Python"
str2="人生苦短，我用Python"
str3="""人生苦短，
我用Python""" 
str4="""人生苦短，
我用Python"""
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

函数名	作用	注意事项	举例
str()	将其它数据类型转成字符串	也可用引号转换	str(123) ‘123’
int()	将其它数据类型转成整数	1、文字类和小数类字符串，无法转成整数；2、浮点数化成整数：抹零取整	int(‘123’) int(98.2)
float()	将其它数据类型转成浮点数	1、文字类无法转成浮点数；2、整数转成浮点数，末尾为.0	float(‘9.9’)、float(9)

python中的注释

• 注释
  • 在代码中对代码的功能进行解释说明的标志性文字，可以提高代码的可读性
  • 注释的内容会被python解释器忽略
  • 通常包括三种类型的注释
    • 单行注释 以’#'开头，直到换行结束
    • 多行注释 并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
    • 中文编码声明注释 在文件开头加上中文声明蛛丝，用一指定的原码文件的编码格式

# 2022/4/3 16:07
#输入功能（单行注释）
print('hello')
'''嘿嘿嘿，
我是
多行注释
'''

#coding:gbk     #或utf-8
# 开发人员：
# 2022/4/3 16:09
#python文件默认编码是UTF-8,编码格式声明注释在首行

第三章

python输入函数input（）

• input（）函数的基本使用

  • 变量 赋值运算符’=’ input（‘input the number：’）

  • present = input(‘大圣想要声明礼物呢？’)

present=input('大圣想要什么礼物呢？')
print(present,type(present))

a=input('请输入一个加数：')
b=input('请输入另一个加数：')
print(type(a),type(b))   #input（）函数是输入一个字符串的数据类型
print(a+b)               #此处+起到的是连接作用
a=int(a)
b=int(b)
print(a+b)

算术运算符

• 标准算术运算符 加（+）、减（-）、乘（*）、除（/)、整除（//）
• 取余运算符 %
• 幂运算符 **

print(1+1)#加法运算
print(1-1)#减法运算
print(2*5)#乘法运算
print(1/2)#除法运算
print(11/2)#除法运算
print(11//2)#整除运算
print(11%2)#取余运算
print(2**8)#幂运算 表示2的8次方
print(2**9)#幂运算 表示2的9次方

• 整除运算中注意事项
  • 一正一负的整除公式，向下取整
  • 余数=被除数-除数*商

print(9//4) #2
print(-9//-4)#2

print(9//-4) #-3
print(-9//4)#-3   一正一负的整除公式，向下取整

print(9%-4) #-3 公式 余数=被除数-除数*商  9-（-4）*（-3）  9-12-->-3
print(-9%4) #3  公式 余数=被除数-除数*商  9-（4）*（-3）  -9+12-->3   

赋值运算符

• 赋值运算符 运算顺序从右到左
• 支持链式赋值 id 属于同一个地址
• 支持参数赋值 +=、-=、*=、/=、//=、%=
• 支持系列解包赋值 a,b,c,=10,20,50 变量个数左右要相同

a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('---------支持参数赋值-----------')
a=20
a+=30  #相当于a+=30
print(a)
print(type(a))
a-=10 #相当于a=a-10
print(a)
a*=2
print(a)
a/=3
print(a)
print(type(a)) #float
a//=2
print(a)
a,b,c=20,30,50
print(a,b,c)
#a,b=20,30,50   报错，因为左右变量的个数和值的个数不对应
print('--------交换两个变量的值-------')
a,b=10,20
print('交换之前',a,b)
#交换
a,b=b,a
print('交换之后',a,b)

比较运算符

• 比较运算符的结果为bool类型

# 2022/4/3 20:44
a,b=10,20
print('a>b吗？',a>b) #False
print('a,a<b)  #True
print('a<=b吗？',a<=b) #True
print('a>=b吗？',a>=b) #True
print('a==b吗？',a==b) #False
print('a!=b吗？',a!=b) #True

'''
一个 = 称为赋值运算符，==称为比较运算符
一个变量由三个部分组成，标识，类型，值
==比较是标识还是值呢？比较的是值
比较对象的标识使用 is
'''
a=10
b=10
print(a==b) #True 说明，a与b的value相等
print(a is b)#True 说明，a与b的id标识，相等
#以下代码没学过，后面会给大家讲解
list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2)
print(list2 is list1)
print(id(list2))
print(id(list1))
print(a is not b)  #False a和b的id标识是不相等的吗
print(list1 is not list2)#True

布尔类型

• 对于布尔值之间的运算

运算符	运 算	数	运算结果	备注
	True	True	True	当两个运算数为True的时，运算结果才为True
and	True	False	False
	False	True	False
	False	False	False
	True	True	True	只要有一个运算数位True，运算结果就为True
	True	False	True
or	False	True	True
	False	False	False
not	True	False		如果运算数为True，运算结果为False
	False	True		如果运算数为False，运算结果为True

位运算符

• 位与& 对应数位都是1，结果数位才是1，否则为0
• 位或| 对应数位都是0，结果数位才是0，否则为1
• 左移位运算符<< 高位溢出舍弃，低位补0
• 右移位运算符>> 低位溢出舍弃，高位补0

print(4&8) #按位与&，
print(4|8) #按位或|，同时为0时结果为0
print(4<<1)#向左移动1位（移动一个位置）相当于乘以2
print(4<<2)#向左移动2位（移动2个位置）

print(4>>1)#向右移动1位，相当于除以2
print(4>>2)#向右移动2位，相当于除以4

运算符的优先级

• 幂运算》乘除取整取余》加减》移位运算》位与》位或》比较运算符》与或布尔运算》赋值运算

第四章

程序的组织结构

计算机的流程控制

• 顺序结构
• 选择结构 if语句
• 循环结构 while语句、for-in语句

print('-------------程序开始----------')
print('1、把冰箱门打开')
print('2、把大象放冰箱里')
print('3、把冰箱门关上')
print('--------------程序结束---------')

对象的布尔值

• python一切皆对象，所有对象都有一个布尔值
  • 获取对象的布尔值
  • 使用内置函数bool（）
• 以下对象的布尔值为False
  • False
  • 数值（）
  • None
  • 空字符串
  • 空列表
  • 空元组
  • 空字典
  • 空集合

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

print('--------其他对象的布尔值为True-------')
print(52)
print('helloworld')

选择结构

• 选择结构 程序根据判断条件的布尔值选择性地执行部分代码 明确地让计算机知道在什么条件下，该去做什么
• 单分支结构 if 判断条件表达式==：==条件执行体1

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

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

#双分支结构if...else，二选一执行
'''从键盘录用一个整数，编写程序让计算机判断是奇数还是偶数'''
num=int(input('请输入一个整数'))

#条件判断
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

• 多分支结构 if条件表达式==：== 条件执行体1 elif: 条件表达式==：== 条件执行体2…elif: 条件表达式==：== 条件执行体Nelse: 条件执行体N+1

'''多分支结构，多选一执行
从键盘录用一个整数 成绩
90-100  A
80-89   B
70-79   C
60-69   D
0-59    E
小于0或大于100 为非法数据（不是成绩的有限范围）
'''
score=float(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("对不起，成绩有误，不在成绩的有效范围")    

另一种表达方式（更为简便）：

'''多分支结构，多选一执行
从键盘录用一个整数 成绩
90-100  A
80-89   B
70-79   C
60-69   D
0-59    E
小于0或大于100 为非法数据（不是成绩的有限范围）
'''
score=float(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 0<=score<=59:
    print('E级')
else:
    print("对不起，成绩有误，不在成绩的有效范围")

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

'''
会员>=200  8折
    >=100 9折
        不打折
非会员 >=200 9.5折'
        不打折
'''
answer=input('您是会员吗？y/n')
money=float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer=='y':
    if  money>=200:
        print('打八折，付款金额为：',money*0.8)
    elif money>=100:
        print('打九折，付款金额为：',money*0.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，否则条件表达式的返回值为False

'''从键盘录入两个整数，比较两个整数的大小'''
num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
'''if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(input(num_a,'小于',num_b))'''
print('使用条件表达式进入比较')
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))

• pass语句
  • 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
  • 什么时候使用：先搭建语法结构，还没想好代码怎么写的时候
  • 哪些语句一起使用：
    • if语句的条件执行体
    • for-in语句的循环体
    • 定义函数时的函数体

#pass语句，什么都不做，只是一个占位符，用到需要写语句的地方
answer=input('你是会员吗？y/n')
#判断是否是会员
if answer=='y':
    pass
else:
    pass

第五章

内置函数range()

• range（）函数
  • 用于生成一个整数序列
  • 创建range对象三种方式
    • range（stop) 创建一个（0，step）之间的整数序列，步长为1
    • range（star，stop） 创建一个（start,stop)之间的整数序列，步长为1
    • range（start，stop，step） 创建一个(start,stop)之间的整数序列，步长为step
  • 返回值是一个迭代器对象
  • range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step,只有当用到range对象时，才会去计算序列中的相关元素
  • in与not in 判断整数序列中是否存在（不存在）指定的整数

'''第一种创建方式，只有一个参数（小括号只给了一个数'''
r=range(10)#【0，1，2，3，4，5，6，7，8，9】，默认从0开始，默认相差1称为步长
print(r)#range（0，10）
print(list(r))#用于查看range对象中的整数序列  -->list是列表的意思

'''第二种创建方式，给了两个参数（小括号中给了两个数'''
r=range(1,10)   #指定了起始值，从1开始，到10 结束（不包含10），默认步长为1
print(list(r))#[1,2,3,4,5,6,7,8,9]

'''第三种创建方式，给了第三个参数（小括号中给了三个数）'''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]

'''判断指定的整数，在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数序列中
print(9 in r)#True，9在当前的r这个序列中
print(range(1,20,1)) #[1,...,19]
print(range(1,101,1))#[1,2,...,100]

循环结构

• 反复做同一件事情的情况，称为循环
• 循环的分类：while/for-in
• while语法结构 while条件表达式：条件执行体（循环体）
• 选择结构的if与循环结构while的区别
  • if是判断一次，条件为True执行一行
  • while是判断N+1次，条件为True执行N次

a=1
#判断条件表达式
while a<10:
    #执行条件执行体
    print(a)
    a+=1

• 四步循环法
  • 初试化变量
  • 条件判断
  • 条件执行体（循环体）
  • 改变变量
• while循环的执行过程

'''4步循环过程
- 初试化变量
- 条件判断
- 条件执行体（循环体）
- 改变变量
总结：初始化的变量与条件判断的变量与改变为同一个
'''
'''初始化变量为0'''
sum=0
a=0
'''条件判断'''
while a<5:
    '''条件执行体（循环体）'''
    sum+=a
    '''改变变量'''
    a+=1
print('和为',sum)

for-in循环

• for-in循环
  • in表达从（字符串、序列等）中一次取值，又称为遍历
  • for-in遍历的对象必须是可迭代对象
• for-in的语法结构
  • for自定义的变量in可迭代对象：循环体
• 循环体内不需要访问自定义变量，可以将自定义变量替代为下划线

for item in 'python': #第一次取出来的是P，将P赋值值item，将item的值输出
    print(item)

#range()产生一个整数序列，--》也是一个可迭代对象
for i in range(10):
    print(i)

#如果在循环体重不需要使用到自定义变量，可将自定义变量写成"_"
for _ in  range(5):
    print('人生苦短，我用python')

sum=0
for item in range(1,101):
    if item%2==0:
        sum+=item
print("1到100之间的偶数和为",sum)

'''输出100到999之间的水仙花数
举例：153=3*3*3+5*5*5+1*1*1

'''
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
#判断
    if ge*ge*ge+shi*shi*shi+bai*bai*bai==item:
        print(item)

流程控制语句

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

'''从键盘录入密码，最多录入3次，如果正确就结束循环    '''
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

a=0;
while a<3:
    '''条件执行体（循环体）'''
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    #改变变量
    a+=1
    

• continue语句

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

'''要求输出1到50之间所有5的背书，5，,10，,15，,20，,25....
    5的倍数的共同点：和5的余数为0的数都是5的倍数
    什么样不的数不是5的倍数，1，,2，,3，,4，,5，,6，,7，8，,9.。。。
'''
for item in range(1,51):
    if item%5==0:
        print(item)


print('------使用continue---------')
for item in  range(1,51):
    if item%5!=0:
        continue
    print

• 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('对不起，三次密码均不正确')

a=0
while a<3:
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    #改变变量
    a+=1
else:
    print('对不起，三次密码均输入错误')

• 嵌套循环

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

'''输出一个三行四列的矩阵'''
for i in range(1,4):#行表，执行三次，一次是一行
    for j in range(1,5):
        print('*',end='\t') #不换行输出
    print()#打行

for i in range(1,10):
    for j in  range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()

• 二重循环中的break和continue

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

'''流程控制语句break与continue在二重循环中的使用  '''
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            #break #仅输出5个1
            continue
        print(j,end='\t')
    print()

第六章

为什么需要列表

• 变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作
• 列表相当于其他语言中的数组
• 列表示意图

			列表
索引	-7	-6	-5	-4	-3	-2	-1
数据	“hello”	“world”	123	98.6	“world”	125	“world”
索引	0	1	2	3	4	5	6

列表的创建

• 列表需要使用中括号[].元素之间使用的英文的都好进行分隔

​ 1st = [‘大圣’,’娟子姐]

​ 列表名 赋值号 中括号

• 列表的创建方式
  • 使用中括号
  • 调用内置函数list（）

'''创建列表的第一种方式，使用[]  '''
lst=['hello','world',98]

'''创建列表的第二种方式，使用内置函数list'''
lst2=list(['hello','world',98])

列表的特点

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

列表的查询操作

• 获取列表中制定元素的索引index()

  • 如查询列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
  • 如果查询的元素在列表中不存在，则会抛出ValueError
  • 还可以制定的start和stop之间进行查找

• 获取列表中的单个元素

  • 正向索引从0到N-1， 举例:lst[0]
  • 逆向索引从-N都-1 举例：lst[-N]
  • 指定索引不存，抛出indexError

  lst=['hello','world',98,'hello']
  print(lst.index('hello'))#如果列表中有相同的元素只返回列表中相同的第一个元素的索引
  #print(lst.index('Python'))#ValueError: 'Python' is not in list
  #print(lst.index('hello',1,3))# ValueError: 'hello' is not in list
  print(lst.index('hello',1,4))
  

lst=['hello','world',98,'hello','love']
print(lst[1])#顺序获取索引为1的元素

print(lst[-1])#逆序获取索引为1的元素 ，范围-1到-N  此处输出为love
#获取索引为10
#print(lst[10])#IndexError: list index out of range

获取列表中的多个操作

• 语法格式 列表名[start:stop:step]
• 切片操作
  • 切片的结果 原列表片段的拷贝
  • 切片的范围 [start,stop]
  • step默认为1 简写为[start,stop]
  • step为正数
    • [:stop:step] 切片的第一个元素默认是列表的第一个元素
    • [start::step] 切片的最后一个元素默认是列表的最后一个元素
    • 从start开始往后计算切片
  • step为负数
    • [:stop:step] 切片的第一个元素默认是列表的最后一个元素
    • [start::step] 切片的最后一个元素默认是列表的第一个元素
    • 从start开始往前计算切片

lst=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step=1
#print(lst[1:6:1]) #[20, 30, 40, 50, 60]

'''原列表id 4367247040
切的片段id： 4368807424
'''
print('原列表id',id(lst))
lst2=lst[1:6:1]
print('切的片段id：',id(lst2))
print(lst[1:6])#默认步长为1
print(lst[1:6:])

#start=1,stop=6,step=2
print(lst[1:6:2])
#start默认,stop=6,step=2
print(lst[:6:2])
#start=1,stop默认,step=2
print(lst[1::2])

print("---------------step步长为负数的情况----------")
print('原列表',lst) #[10, 20, 30, 40, 50, 60, 70, 80]
print(lst[::-1]) #[80, 70, 60, 50, 40, 30, 20, 10]

#start=7，stop省略，step=-1
print(lst[6::-1]) #[70, 60, 50, 40, 30, 20, 10]

#start=6，stop=0,step=-2
print(lst[6:0:-2]) #[70, 50, 30]

列表元素的查询操作

• 判断指定元素在列表中是否存在

• ​ 元素 in 列表名

  ​ 元素 not in 列表名

• 列表元素的遍历

  • for 迭代遍历 in 列表名：操作

print('p'in 'python')
print('k' not in 'python')

lst=[10,20,'python','hello']
print(10 in lst) #True
print(100 in lst)#False
print(10 not in lst)#False
print(100 not in lst)#True

print('-------------')
for item in lst:
    print(item)

列表元素的增加操作

• 	方法/其他	操作描述
  增	append（）	在列表的末尾添加一个元素
  加	extend（）	在列表的末尾至少添加一个元素
  操	insert（）	在列表的任意位置添加一个元素
  作	切片	在列表的任意位置添加至少一个元素

#向列表的末尾添加一个元素
lst=[10,20,30]
print('在添加元素之前',lst,id(lst))
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2=['hello','world']
#lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
#向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)

lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:]=lst3
print(lst)

列表元素的删除操作

• 	方法/其他	操作描述
  		一次删除一个元素
  	remove()	重复元素只删除第一个
  删		元素不存在抛出ValueError
  除
  操		删除一个指定索引位置上的元素
  作	Pop()	制定索引不存在抛出ValueError
  		不指定索引，删除列表中最后一个元素
  	切片	一次至少删除一个元素
  	clear()	清空列表
  	del	删除列表

lst=[10,20,30,40,50,60,30]#从列表中移除
lst.remove(30)
print(lst)
#lst.remove(100)    #ValueError: list.remove(x): x not in list

#pop()根据索引移除元素
lst.pop(1)
print(lst)  #[10, 40, 50, 60, 30]
#lst.pop(5)  #IndexError: pop index out of range
lst.pop()   #如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)

print('-------------切片操作-删除至少一个元素，将产生一个列表对象-------')
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)

'''不产生新的列表对象，而是删除原列表中的内容    '''
lst[1:3]=[]
print(lst)

'''清除列表中的所有元素'''
lst.clear()
print(lst)

'''del语句将列表对象删除  '''
del lst
#print(lst) #NameError: name 'lst' is not defined.

列表元素的修改操作

• 为指定索引的元素赋予一个新值
• 为指定的切片赋予一个新值

lst=[10,20,30,40,50]
#一次修改一个值
lst[2]=52
print(lst)

#一次修改多个值
lst[1:3]=[232,123,521]
print(lst)

列表元素的排序操作

• 常见的两种方式
  • 调用sort()方法，列中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序 排序
  • 调用内置函数sorted(),可以指定reverse=True，进行降序 排序，原列表不发生改变

lst=[60,50,30,20,90,10]
print('排序前的列表',lst,id(lst))
#开始排序，调用列表对象的sort方法，升序排序
lst.sort()
print('排序后的列表',lst,id(lst))
'''
排序前的列表 [60, 50, 30, 20, 90, 10] 4374767296
排序后的列表 [10, 20, 30, 50, 60, 90] 4374767296
'''
#通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)#reverse=True 表示降序排序，reverse=False就是升序排序
print(lst)
#[90, 60, 50, 30, 20, 10]
lst.sort(reverse=False)#reverse=True 表示降序排序，reverse=False就是升序排序
print(lst)

print("----------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-------")
lst=[20,30,10,98,53]
print('原列表',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list)
#指定关键字参数，实现列表元素降序排列
desc_list=sorted(lst,reverse=True)
print(desc_list)

列表生成式

• 列表生成式简称“生成列表的公式”
  • 语法格式：[i*i for i in range(1,10)] 表示列表元素的表达式 for 自定义变量 in 可迭代对象
  • 注意事项：“表示列表元素的表达式”中通常包含自定义变量

lst=[i for i in range(1,10)] #[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst)
lst=[i*i for i in range(1,10)]  #[1, 4, 9, 16, 25, 36, 49, 64, 81]
print(lst)

'''列表中的元素的值为2，4，6,8，10...'''
lst2=[i*2 for i in range(1,6)]#[2, 4, 6, 8, 10]
print(lst2)

第七章

什么是字典

• 字典

  • python内置的数据结构之一，与列表一样是一个可变序列，str字符串是不可变序列
  • 以键值对的方式存储数据，字典是一个无序的序列
  • 格式：scores={‘张三’：100，‘李四’：98，‘王五’:52} 字典名 = 花括号 键：值 , 键：值 花括号

• 字典示意图

hash(key3)		Hash(key2)			hash(key1)			hash(key5)
Key3		key2			key1			Key5
v		v			v			v
Value3		Value2			value1			Value5

• 字典的实现原理

  • 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，python中的字典是根据key查找value所在的位置

• 字典的创建

  • 最常用的方式：使用花括号scores={‘张三’：100，‘李四’：98，‘王五’:52}
  • 使用内置函数dict（） dict(name=‘jack’,age=20)

#字典的创建方式
'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':52}
print(scores)
print(type(scores))

'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student)

'''空字典'''
di=dict()
print(di)

字典的常用操作

• 字典中元素的获取

  • [ ] 举例：scores[‘张三’]
  • get()方法： 举例：scores.get(‘张三’)
  • []取值与使用get()取值的区别
    • []如果字典中不存在指定的key，抛出keyError异常
    • get()方法取值，如果字典中不存在指定的key，并不会抛出keyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

#获取字典的元素
scores={'张三':100,'李四':98,'王五':52}
'''第一种方式，使用[]'''
print(scores['张三']) #100
#print(scores['小明'])#KeyError: '小明'

'''第二章方式，使用get（）方法'''
print(scores.get('张三'))
print(scores.get('小明'))#None
print(scores.get('麻瓜',66))#66是在查找'麻瓜'所对的value

• key的判断
  • In 指定的key在字典中存在返回True ‘张三’ in scores
  • In 指定的key在字典中不存在返回True ‘Marry’ not in scores
• 字典元素的删除 del scores[‘张三’]
• 字典元素的新增 score[‘jack’]=90

#key的判断
scores={'张三':100,'李四':98,'王五':52}
print(scores)
print('张三' in scores)
print('张三' not in scores)

del scores['张三']#删除指定的key-value对
#score.clear() #清空字典的元素
print(scores)
scores['陈六']=98
print(scores)

scores['陈六']=100
print(scores)

• 获取字典视图的三个方法

  • Keys() 获取字典中所有key
  • values() 获取字典中所有value
  • items() 获取字典中所有key，value对

scores={'张三':100,'李四':98,'王五':52}
#获取所有的key
keys=scores.keys()
print(keys)
print(type(keys))#
print(list(keys))#将所有的可以组成的视图转成列表

#获取所有的value
values=scores.values()
print(values)
print(type(values))#
print(list(values))

#获取所有的key-value对
items=scores.items()
print(items) # dict_items([('张三', 100), ('李四', 98), ('王五', 52)])

print(list(items)) #转换之后的列表元素是由元组组成（元组将在下一个章节讲解） [('张三', 100), ('李四', 98), ('王五', 52)]

• 字典元素的遍历

  • 语法格式： for item in scores: print(item)

scores={'张三':100,'李四':98,'王五':52}
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

• 字典的特点

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

d={'name':'张三','name':'李四'} #key不允许重复
print(d) #{'name': '李四'}

d={'name':'张三','nikename':'张三'}
print(d)  #{'name': '张三', 'nikename': '张三'}

lst=[10,20,30]
lst.insert(1,100)
print(lst) # [10, 100, 20, 30]
d={lst:100}#lst是可变的序列，不允许，必须为不可变对象，TypeError: unhashable type: 'list'
print(d)#TypeError: unhashable type: 'list'

• 字典生成式

  • 内置函数zip() 用于将可迭代的对象做完参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
  • 字典生产式：{item.upper():price for item.price in zip(items,price)} 即{ 表示字典key的表达式（）：表示字典value的表达式 for 自定义表示key的变量 in 可迭代对象}

item=['Fruits','Books','Others']
prices=[96,78,85,100,120]

d={item.upper():price for item,price in zip(item,prices)}
print(d) #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}       prices列表中多余被压缩

第八章

什么是元组

• 元组
  • python内置的数据结构之一，是一个不可变序列
• 不可变序列与可变序列
  • 不可变序列：字符串、元组
    • 不可变序列：没有增、删、改的操作
  • 可变序列：列表、字典
    • 可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

#不可变序列，可变序列
#不可变序列 字符串、元组
s='hello'
print(id(s))#4337127024
s=s+'world'
print(s) #helloworld
print(id(s))#4337157680

#可变序列，列表、字典
lst=[10,20,30]
print(id(lst))#4334023872
lst.append(300)
print(id(lst))#4334023872 id地址不更改

• 元组的创建方式

  • 直接小括号 t=(‘python’,‘hello’,90)
  • 使用内置函数tuple() t=tuple((‘python’,‘hello’,90))
  • 只包含一个元组的元素需要使用逗号和小括号 t=(10, )

#元组创建方式
#第一种创建方式，使用()
t=('Python','world',98)
print(t)
print(type(t))

t2='Python','world',98 #省略了小括号
print(t2)
print(type(t2))

t3=('python')#无逗号 如果元组中只有一个元素，逗号不能省
print(t3)
print(type(t3))#
t3=('python',)
print(type(t3))#

#第二种创建方式，使用内置函数tuple（）
t5=tuple(('Python','world',98))
print(t5)
print(type(t5))

#空元组的创建方式
#空列表的创建方式
lst=[]
lst1=list()

d={}
d2=dict()

#空元组
t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

为什么要将元组设计成不可变序列

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

t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))#10  4341154320
print(t[1],type(t[1]),id(t[1]))#[20, 30]  4341904576
print(t[2],type(t[2]),id(t[2]))#9  4341154288
'''尝试将t[1]修改为100 '''
print((id(100)))#4341157200
#t[1]=100 #元组是不允许修改元素的  AttributeError: type object 'int' has no attribute 'id'
t[1].append(100) #向列表中添加元素
print(t,id(t[1]))#(10, [20, 30, 100], 9) 4341904576

• 元组的遍历

  • 元组是可迭代对象，所以可以使用for…in进行遍历
    • t=tuple(((‘Python’,‘world’,98))) for item in t: printf(item)

#元组遍历
    t=('Python','world',98)
#第一种获取元组元素的方式，使用索引
print(t[0])
print(t[1])
print(t[2])
#print(t[3])#IndexError: tuple index out of range

'''遍历元组 '''
for item in t:
    print(item)

第八章

什么是集合

• 集合
  • Python语言提供的内置数据结构
  • 与列表、字典一样都属于可变类型的序列
  • 集合是没有value的字典

hash(dataA)		hash(dataB)	hash(dataC)	hash(dataD)
dataA		dataB	dataB	dataD

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

#第一种创建方式使用{}
s={2,3,3,5,6,7,7,}#{2, 3, 5, 6, 7} 集合中不允许重复
print(s)

#第二种创建方式使用set()
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,5,5,5,6,6])
print(s2,type(s2))
s3=set((1,2,3,3,5,5,52)) #集合中的元素是无序的
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))
s5=set({1,2,3,5,6,7,8,22})
print(s5,type(s5))
#定义一个空集合
s6={}#dict字典类型
print(type(s6))
s7=set()
print(s7,type(s7))

集合的相关操作

• 集合元素的判断操作
  • in或not in
• 集合元素的新增操作
  • 调用add()方法，一次添中一个元素
  • 调用update()方法至少添中一个元素
• 集合元素的删除操作
  • 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
  • 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
  • 调用pop()方法，一次只删除一个任意元素
  • 调用clear()方法，清空集合

s={10,20,30,408,60}
#判断元素的判断操作
print(10 in s)#True
print(100 in s)#False
print(10 not in s)#False
print(100 not in s)#True
#集合元素的新增操作
print('------集合元素的新增操作------')
s.add(80)
print(s)
s.update({200,400,500})
print(s)
s.update([521,600,800])
print(s)
s.update((999,123))
print(s)
#集合元素删除操作
print('----集合元素删除操作-----')
s.remove(200)
print(s)
s.pop()
print(s)
s.pop()
print(s)
#s.pop(123)#TypeError: set.pop() takes no arguments (1 given)
s.clear()
print(s)

集合间的关系

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

#判断两个集合时候相等（元素相同，就相等）
s={10,20,30,40}
s2={30,50,60,80}
print(s==s2)#False
print(s!=s2)#True

'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40,50}
s3={10,20,52}
print(s2.issubset(s1))#True
print(s3.issubset(s1))#False

#一个集合是否是另一个集合的超集
print(s1.issuperset(s2))#True
print(s1.issuperset(s3))#False

#两个集合是否含有交集
print(s2.isdisjoint(s3))#False  有交集为False
s4={100,200,300}
print(s2.isdisjoint(s4))#True  没有交集为True

集合的数学操作

• #集合的数字操作
  #(1)交集
  s1={10,20,30,50}
  s2={20,30,50,60}
  print(s1.intersection(s2))
  print(s1 & s2)#intersection()与&等价，交集操作
  
  print(s1)
  print(s2)
  #(2)并集操作
  print(s1.union(s2))
  print(s1|s2)   #union与 | 等价，并集操作
  print(s1)
  print(s2)
  #(3)差集操作
  print(s1.difference(s2))
  print(s1-s2)
  #(4)对称差集
  print(s1.symmetric_difference(s2))
  print(s1^s2)#symmetric_difference(s2)与^ 等价，并集操作
  

• 集合生成式

  • 用于生成集合的公式 {i*i for i in range(1,10)}
  • 用于生成集合的公式 即=={表示集合元素的表达式 for 自定义变量 in 可迭代变量}==
  • 没有元组生成式

#列表生成式
lst=[i*i for i in range(10)]
print(lst)

#集合生成式
s={i*i for i in range(10)}
print(s)

列表、字典、元组、集合总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	()
字典（dict）	可变	key不可重复	无序	{key:value}
字典（dict）	可变	value可重复	无序	{key:value}
集合（set）	可变	不可重复	无序	{}

第九章

字符串

• 在python中字符串是基本数据类型，是一个不可变的字符序列

什么叫字符串驻留机制呢？

• 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

#字符串的驻留机制
a='Python'
b="Python"
c='''Python'''
print(a,id(a))#Python 4345797360
print(b,id(b))#Python 4345797360
print(c,id(c))#Python 4345797360

驻留机制的几种情况（交互模式）

• 字符串的长度为0或1时
• 符合标识符的字符串
• 字符串只在编译时进行驻留，而非运行时
• [-5,256]之间的整数数字

sys中的intern方法强制2个字符串指向同一个对象

Pycharm对字符串进行了优化处理

字符串驻留机制的优缺点

• 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
• 在需要进行字符串拼接时建议使用str类型的jion方法，而非+，因为join（）方法是先计算所有字符中的长度，然后在拷贝，只new一次对象，效率要比“+”效率高

s1='abc%'
s2='abc%'
print(s1 is s2)

字符串的查询操作的方法

功能	方法名称	作用
查	Index()	查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
询	Rindex()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
方	Find()	查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
法	Rfind()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

#字符串的查询操作
s='hello,hello'
print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rindex('lo'))#9
print(s.rfind('lo'))#9

#print(s.index('k'))#ValueError: substring not found
print(s.find('k'))#-1
#print(s.rindex('k'))#ValueError: substring not found
print(s.rfind('k'))#-1

字符串的大小写转换操作的方法

功能	方法名称	作用
大	Upper()	把字符串中所有字符都转成大写字母
小	Lower()	把字符串中所有字符都转成小写字母
写	Swapcase()	把字符串中所有大写字母都转成小写字母，把所有线小写字母都转成大写字母
转	Capitalize()	把第一个字符转换为大写，把其余字符转成小写
换	Title()	把每个单词的第一个转换为大写，把每个单词的剩余字符转换为小写

#字符串中的大小写转换的方法
s='hello,python'
a=s.upper()#转成大写之后，会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b=s.lower()
print(b,id(b))
print(s,id(s))
print(b==s)
print(b is s)#False

s2='hello,Python'
print(s2.swapcase())
print(s2.title())

• 字符串内容对齐操作的方法

功能	方法名称	作用
字	Center()	居中对其，第一个参数指定宽度，第2个参数指定填充符，第2 个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
符	ljust（）	左对齐，第一个参数指定宽度，第2个参数指定填充符，第2 个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
串	rjust()	右对齐，第一个参数指定宽度，第2个参数指定填充符，第2 个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
对齐	Zfill()	右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

s='hello,Python'
#居中对齐
print(s.center(20,'*'))
#左对齐
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
#右对齐
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))
print('-5201314'.zfill(20))

• 字符串劈分操作的方法

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

s='hello world Python'
lst=s.split()#['hello', 'world', 'Python']
print(lst)
s1='hello|world|Python'
print(s1.split(sep='|'))#['hello', 'world', 'Python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|Python']
print("----------rsplit()从右边开始劈分------")
print(s.rsplit())#['hello', 'world', 'Python']
print(s1.rsplit('|'))#['hello', 'world', 'Python']
print(s1.rsplit(sep='|',maxsplit=1))#['hello|world', 'Python']

• 判断字符串操作的方法

功能	方法名称	作用
判	Isidentifier()	判断指定的字符串是不是合法的标识符
断	Isspace()	判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
字	Isalpha()	判断指定的字符串是否全部由字母组成
符	Isdecimal()	判断指定的字符串是否由十进制的数字组成
串的	Isnumeric()	判断指定的字符串是否全部由数字组成
方法	Isalnum（）	判断指定的字符串是否全部由字母和数字组成

s='hello,python'
print('1.',s.isidentifier())#False
print('2.','hello'.isidentifier())#True
print('3.','张三_'.isidentifier())#True
print('4.','张三_123'.isidentifier())#True

print('5.','\t'.isspace())#True

print('6.','abc'.isalpha())#True
print('7.','张三'.isalpha())#True
print('8.','张三1'.isalpha())#False

print('9.','123'.isdecimal())#True
print('10.','123四'.isdecimal())#False
print('11','Ⅱ ⅢⅣ'.isdecimal())#False

print('12.','123'.isnumeric())#True
print('13.','123四'.isnumeric())#True
print('14','Ⅱ ⅢⅣ'.isnumeric())#False

print('15.','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc!'.isalnum())#False

• 字符串操作的其它方法

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

s='hello,Python'
print(s.replace('Python','Java'))
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))#hello,Java,Java,Python

lst=['hello','Java','Python']
print('|'.join(lst))#hello|Java|Python
print(''.join(lst))#helloJavaPython

t=('hello','Java','Python')
print(''.join(t))#helloJavaPython

print('*'.join('Python'))#P*y*t*h*o*n

• 字符串的比较操作
  • 运算符：>,>=,<=,==,!=
  • 比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，一次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
  • 比较原理：两上字符比较时，比较的是其ordinal value(原始值),调用内置函数ord可以 得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符

print('apple'>'app')#True
print('apple'>'banana')#False
print(ord('a'),ord('b'))
print(ord('轩'))

print(chr(97),chr(98))
print(chr(36713))

'''==与is的区别
==比较的是value
is比较的是id是否相等'''
a=b='Python'
c='Python'

print(a is b)#True
print(a is c)#True
print(id(a))#驻留机制4373568240
print(id(b))#驻留机制4373568240
print(id(c))#驻留机制4373568240

• 字符串是不可变类型
  • 不具备增、删除、改等操作
  • 切片操作间产生新的对象

s='hello,Python'
s1=s[:5]#由于没有指定起始位置，所以从0开始切
s2=s[6:]#由于没有指定结束位置，所以切到字符串的最后一个元素
s3='!'
newstr=s1+s3+s2

print(s1)
print(s2)
print(newstr)
print('___________')
print(id(s))
print(id(s1))
print(id(s2))
print(id(newstr))

print('------------切片[start:end:step]---------')
print(s[1:5:1])  #从1开始截到5（不包含5），步长为1
print(s[::2])   #默认从0 开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1])   #默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1])    #从索引为-6开始，到字符串的最后一个元素结束，步长为1

• 格式化字符串的两种方式
  • %作占位符 ‘my name is %s,i’m %d years old’ 定义的格式化字符串 固定符号% (name,age) （实际值，实际值）
  • {}作占位符 ‘my name is {0},i’m {0} years old’ format{name,age}

#(1)%占位符
name='张三'
age=20
print('我叫%s，今年%d岁'%(name,age))

#(2) {}
print('我叫{0}，今年{1}岁'.format(name,age))

#f-string
print(f'我叫{name},今年{age}岁')

print('%10d'%99)#10表示的是宽度
print('%.3f'%3.1415926)#.3表示是小数点后三位
#同时表示宽度和精度
print('%10.3f'% 3.1415926)#一共总宽度为10。小数点后3位

print('hellohello')

print('{0:3}'.format(3.1415926)) #.3表示的是一共3位小数
print('{:.3f}'.format((3.1415926)))#.3f表示的是3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度，一共是10位，3位是小数

• 编码与解码的方式

  • 编码：将字符串转换为二进制数据（bytes）
  • 解码：将bytes类型的数据转换成字符串类型

  s='天涯共此时'
  #编码
  print(s.encode(encoding='GBK'))#在GBK这种编码格中  一个中文占两个字节
  print(s.encode(encoding='UTF-8'))#在UTF-8这种编辑格式中，一个中文占三个字节
  
  #解码
  #byte代表就是一个二进制数据（字节类型的数据）
  byte=s.encode(encoding='GBK')  #编码
  print(byte.decode(encoding='GBK'))  #解码
  
  byte=s.encode(encoding='UTF-8')
  print(byte.decode(encoding='UTF-8'))
  

第十章

函数的创建和调用

• 什么是函数

  • 函数就是执行特定任务和以完成特定功能的一段代码

• 为什么需要函数

  • 复用代码
  • 隐藏实现细节
  • 提高可维护性
  • 提高可读性便于调试

• 函数的创建

  • def 函数名（[输入参数]）

    函数体

    [return xxx]

def calc(a,b):
  c=a+b
  return c
result=calc(10,20)
print(result)

函数调用的参数传递

位置实参

• 根据形参对应的位置进行实参传递

关键字实参

• 根据形参名称进行实参传递

def calc(a,b):#a,b称为形式参数，简称形参，形参的位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)#10，,20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)

res=calc(b=10,a=20)  #  =左侧的变量的名称称为 关键字参数
print(res)

函数调用的参数传递内存分析图

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

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2) #将位置传参，arg1,arg2,是函数定义处的形参，n1,n2是函数调用的处的实参，总结：实参名称与形参名称可以不一致
print('n1',n1)
print('n2',n2)
'''在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值 arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值，arg2的修改，append（10），会影响到N2的值'''

函数返回多个值时，结果为元组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dgkzGjg0-1650767051607)(/Users/fanxuanhan/Library/Application Support/typora-user-images/image-20220416180849347.png)]

def fun(num):
    odd=[ ] #存奇数
    even=[ ] #存偶数
    for i in num:
        if i%2==0:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

#函数的调用
lst=[16,29,23,52,53,55,408]
print(fun(lst))

'''
函数的返回值
    （1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
    （2）函数的返回值，如果是1个，直接返回类型
    （3）函数的返回值，如果是多个，返回的结果为元组
    '''
def fun1():
    print('hello')
    #return

fun1()

def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3():
    return 'hello','world'
print(fun3())
'''函数在定义时，是否需要返回值视情况而定'''

函数定义默认值参数

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

def fun(a,b=10): #b称为默认值参数
    print(a,b)

#函数的调用
fun(100)
fun(20,30)

print('hello',end='\t')
print('world')

函数的参数定义

• 个数可变的位置参数
  • 定义函数时，可能无法实现确定传递的位置实参的个数时，使用可变的位置参数
  • 使用*定义个数可变的位置形参
  • 结果为一个元组
• 个数可变的关键字形参
  • 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
  • 使用**定义个数可变的关键字形参
  • 结果为一个字典

def fun(*args):#函数定义时的可变的位置参数
    print(args)
    #print(args[0])
fun(10)
fun(10,30)
fun(30,408,50)

def fun1(**args):
    print(args)

fun1(a=10)
fun1(a=20,b=30,c=40)

print('hello','world','java')
'''def fun2(*args,*a):
    pass
    以上代码会报错，个数可变的位置参数，只能是1个
    def fun2(**args,**args):
    pass
    以上代码会报错，个数可变的关键字参数，只能是1个'''
def fun2(*arg1,**arg2):
    pass
'''
    def fun3(**args1,*arg2):
    pass
    在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
    '''

函数的参数总结

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)#在函数调用时，将列表中的每个元素都转换为位置实参传入
print('------------------')
fun(a=100,c=300,b=200)#函数的调用，所以是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic)#在函数调用时，将字典中的键值对转换为关键字实参传入

def fun(a,b=10): #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=',a)
    print('b=',b)

def fun2(*args):#个数可变的位置形参
    print(args)
def fun3(**args2):#个数可变的关键字形参
    print(args2)

fun2(10,20,30,408,52)
fun3(a=11,b=22,c=33,d=44,e=55)

def fun4(a,b,*,c,d):#从*之后的参数，在函数调用时，只能采用关键字传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#调用fun4函数
#fun4(10,20,30,40)#位置实参传递
fun4(a=10,b=20,c=30,d=40)#关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数，采用的是位置实参传递，而c,d采用的是关键字实参传递
'''需求，c,d只能采用关键字实参传递'''

#函数定义时的形参的顺序问题
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**arg2):
    pass

变量的作用域

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

def fun(a,b):
    c=a+b  #c，就称为局部变量，因为c在函数体内进行定义的变量，a,b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)

#print(c),因为a,c超出了起作用的范围（超出了作用域）
#print(a)
name='周杰伦'
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age #函数内部din
    age=20
    print(age)
fun3()
print(age)

递归函数

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

使用递归来计算阶乘

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(6))

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

知识点总结

第十一章

bug的由来及分类

• 世界上第一部万用计算机的进化版-马克2号（Mark II）

• Debug

  Bug的常见类型

  • 粗心导致的语法错误SyntaxError

  age=input('input your age:')
  print(type(age))
  if int(age)>=18:
      print('adult')
  i=0
  while i<10:
      print(i)
      i+=1
  

  • 粗心导致错误的自查宝典

    • 漏了末尾的冒号，如if语句，循环语句，else子句等

    • 缩进错误，该缩进的没缩进，不该缩进的瞎缩进

    • 把英文符号写成中文符号，比如说：引号，冒号，括号

    • 字符串拼接的时候，把字符串和数字拼在一起

    • 没有定义变量,比如while的循环条件的变量

    • “==”比较运算符和“=”赋值运算符的混用

  • 知识不熟练导致的错误

    • 索引越界问题IndexError

      lst=[11,22,33,44]

      Print(lst[4])

  • ​ Append()方法的使用掌握不熟练
    lst=[]
    lst=append(‘A’,‘B’,‘C’)
    Print(lst)

lst=[11,22,33,44]#列表的索引是从0开始
#print(lst[4])
print(lst[3])

lst=[]
#lst=append('A','B','C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)

• 思路不清导致的问题解决方案

  • 使用print()函数
  • 使用"#"暂时注释部分代码

  
  

  

• 被动掉坑：程序代码逻辑没有错，知识因为用户错误操作或者一些“列外情况”而导致的程序崩溃

• 被动掉坑解决方案

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

  

  try:
       a=int(input('请输入第一个整数：'))
       b = int(input('请输入第二个整数：'))
       result=a/b
       print('结果为',result)
  except ZeroDivisionError:
      print('对不起，除数不允许为0')
  print('程序结束')
  

  多个except结构

  • 捕获异常的顺序先按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException

try:
     a=int(input('请输入第一个整数：'))
     b = int(input('请输入第二个整数：'))
     result=a/b
     print('结果为',result)
except ZeroDivisionError:
    print('对不起，除数不允许为0')
except ValueError:
    print('只能输入数字串')
print('程序结束')

try…except…else结构

• 如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块

  

try:
    a=int(input('请输入第一个整数：'))
    b=int(input('请输入第一个整数：'))
    result=a/b
except BaseException as e:
    print('出错了',e)
else:

    print('计算结果为：',result)

try…except…else结构

• finally块无论时候发生异常都会被执行，能常用来释放try块中申请的资源

Python常见异常类型

#print(10/0)#ZeroDivisionError

lst=[11,22,33,44]
#print(lst[4])#IndexError
dic={'name':'张三','age':20}
#print(dic['gener'])#KeyError
#print(num)#NameError
#int a=20 #SyntaxError
#a=int('hello')#ValueError

Python的异常处理机制

• traceback模块打印异常信息

#print(10/0)
import traceback
try:
    print('------------')
    print(1/0)
except:
    traceback.print_exc()

Pycharm开发环境的调试

知识点总结

第十二章

编程思想

• 编程界两大阵营

类

类别，分门别类，物以类聚，人类，鸟类，动物类，植物类…

类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质

数据类型

不同的数据类型属于不同的类

使用内置函数查看数据类型–print(type(变量))

对象

100、99、520都是int类之下包含的相似的不同个例，这个个例专业术语称为实例或对象

类的创建

创建类的语法：class Student：

​ pass

class Student:#Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    pass
#Python中一切皆对象Student是对象吗？内存有开空间吗
print(id(Student))#5073195632
print(type(Student))#
print(Student)#

类的组成

• 类属性

• 实例方法

• 静态方法

• 类方法

class Student:#Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace='吉林'   #直接写在类里的变量，称为类属性
    def__init__(self,name,age):
        self.name=name #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
        self.age=age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')