第二周总结
用户交互
1.获取用户输入
获取用户输入
input
username = input('请输入你的用户名>>>:')
"""
1.先执行input获取用户输入
2.将输入的数据绑定给变量名username
3.以后在程序中就可以使用变量名反复调用用户数据
"""
input获取到的数据都会统一处理成字符串类型
2.输出内部信息
输出内部信息
print
"""
1.括号内既可以放数据值也可以放变量名 并且支持多个 逗号隔开即可
2.print自带换行符
换行符:\r\n(斜杠与字母组合到一起可能会产生特殊的含义)
3.print也可以切换结束符
print(数据, end = '默认是\n')
"""
扩展:python2与python3中两个关键字的区别
python2中
input方法需要用户自己提前指定数据类型 写什么类型就是什么类型
raw_input方法与python3中input一致 输入的统一处理成字符串
python2中
print方法有两种使用方式
print 数据值
print(数据值)
3.格式化输出
提前定义好一些内容 将来需要使用的时候可以局部修改
eg:合同、奖状、录取通知书
代码实现
在现实生活中大部分情况下使用下划线提示别人填写内容
但是在程序中需要使用占位符:%s %d
info = '%s同志你好'
'''单个占位符'''
print(info % 'Jason') # Jason同志你好
print('%s同志你好' % 'Tony') # Tony同志你好
print(info % ('jason',))
print('%s同志你好' % ('Tony',))
'''多个占位符'''
desc = '姓名:%s 年龄:%s 爱好:%s'
print(desc % ('jason', 18, 'read')) # 姓名：jason 年龄:18 爱好:读书
print('姓名:%s 年龄:%s 爱好:%s' % ('tony', 28, 'rap')) # 姓名：tony 年龄:28 爱好:rap
'''注意事项:有几个占位符就需要几个数据值'''
print('my name is %s my age is %s' % ('jason',)) # 少了不行 会报错
print('my name is %s my age is %s' % ('jason', 18, 'read')) # 多了也不行 也会报错
'''不同占位符的区别'''
demo1 = '%s您好 您本月的话费是%s 余额是%s' # %s常见数据类型都支持
print(demo1 % ('jason', 100, 10000000000000)) # jason您好 您本月的话费是100 余额是10000000000000
demo2 = '%d您好 您本月的话费是%d 余额是%d' # %d只支持数字类型
print(demo2 % ('tony', 1000000000, -100000)) # 运行会因为tony不是数字类型而出错
print('%08d'% 123) # 00000123
print('%08d'% 1234324324) # 1234324324
运算符
1.基本运算符
1.1数学运算符
+ - * / %(取余) //（取整） **（次方）
简化写法
n = 10
n += 1 # n = n + 1
n -= 1 # n = n - 1
n *= 1 # n = n * 1
n /= 1 # n = n / 1
n %= 1 # n = n % 1
n //= 1 # n = n // 1
n **= 1 # n = n ** 1
1.2比较运算符
< > <= >= ==(等于号) !=(不等于)
2.常用赋值符
2.1链式赋值
name = 'jason'
name1 = name
name2 = name
链式赋值
name = name1 = name2 = 'jason'
2.2交叉赋值
m = 100
n = 999
'''让m和n互相转换绑定的值'''
"""错误示写法"""
m = n
n = m
print(m, n) # 999 999
'''方式1:采用中间变量'''
temp = m
m = n
n = temp
print(m, n) # 999 100 这种方法不是最好的
'''方式2:交叉赋值语法'''
m, n = n, m
print(m, n) # 999 100 简化最好用这种
2.3解压赋值
name_list = ['jason', 'kevin', 'tony', 'oscar']
'''low的写法'''
name1 = name_list[0]
name2 = name_list[1]
name3 = name_list[2]
name4 = name_list[3]
'''解压赋值语法'''
name1, name2, name3, name4 = name_list
'''解压赋值在使用的时候 正常情况下需要保证左边的变量名与右边的数据值个数一致'''
a, b = name_list # 变量名少了不行 运行会报错
a, b, c, d, e = name_list # 变量名多了也不行 运行也会报错
'''当需要解压的数据个数特别多 并且我们只需要使用其中的几个 那么可以打破上述的规则'''
a, *b = name_list # *会自动接收多余的数据 组织成列表赋值给后面的变量名
print(a) # jason
print(b) # ['kevin', 'tony', 'oscar']
a, c, *b = name_list
print(a) # jason
print(c) # kevin
print(b) # ['tony', 'oscar']
a, *b, c = name_list
print(a) # jason
print(b) # ['kevin', 'tony']
print(c) # oscar
'''当数据值不准备使用的时候 可以使用下划线作为变量名绑定'''
a, *_, c = name_list
3.逻辑运算符
'''主要配合条件一起使用'''
and 与
and连接的多个条件必须全部成立 结果才成立
eg:
你去相亲提要求:身高必须是160以上、长相必须好看、家里必须有钱、性格必须温柔 身高 and 长相 and 有钱 and 温柔
1 > 2 and 4 < 8 and 10 < 1 and 1 == 2
如果条件中全部由and组成那么判断起来非常的简单 只要发现一个不成立 结果就不成立
print(1 < 10 and 666) # 666 成立
print(1 < 10 and 2 < 8) # True 成立
print(111 and 222) # 222 成立
如果需要你准确的说出具体的结果值 那么需要按照下列方式
如果and左边的条件是成立的 那么就完全取决于右边的条件
右边如果直接是数据值 那么结果就是该数据值 如果是含有表达式 则为布尔值
or 或
or连接的多个条件只要有一个成立 结果就成立
eg:
你去相亲提要求:要么家里有钱 或者家里有势 或者长得完美 或者对你死心塌地 有钱 or 有势 or 好看 or 专一
1 > 2 or 4 < 8 or 10 < 1 or 1 == 2
如果条件中全部由or组成那么判断起来非常的简单 只要发现一个成立 结果就成立
print(1 < 10 or 666) # True
print(666 or 1 > 10) # 666
print(0 or False) # False
print(0 or 111) # 111
规律用and
not 非
取反
类似于说反话
"""
三者混合使用的时候有优先级之分 但是我们不需要记忆优先级 应该通过代码的形式提前规定好优先级
eg: 先乘除有加减 但是可以使用括号来改变优先级
(3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)
"""
4.成员运算符
判断个体在不在群体内
name_list = ['jason', 'kevin', 'oscar', 'jerry']
print('tony' in name_list) # False
print('tony' not in name_list) # True
print('j' in name_list) # False 列表最小单位是数据值 不能再细分
s1 = 'hello world'
print('d' in s1) # 字符串最小单位是单个单个的字符
d1 = {
'username': 'jason',
'pwd': 123
}
print('jason' in d1) # False 字典成员运算只有键参与
print('username' in d1) # True 'username' 'pwd'
5.身份运算符
"""
id() 返回一串数字 该数字可以看成是内存地址
"""
is 判断内存地址是否相同
== 判断数据值是否相同
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
l2 = [11, 22, 33, 44, 55, 66, 77, 88]
print(l1 == l2) # True
print(id(l1))
print(id(l2))
print(l1 is l2) # False
小整数池
i1 = 11
i2 = 11
print(i1 is i2) # true
s1 = 'jason jason jason'
s2 = 'jason jason jason'
print(s1 is s2) # true
不同的环境下可能优化的程度不一样
"""
了解
值相同 内存地址可能不同
内存地址相同 值肯定相同
"""
垃圾回收机制
什么是垃圾回收机制
垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间
为什么要用垃圾回收机制？
程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃，因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。
"""
有一些语言 内存空间的申请和释放都需要程序员自己写代码才可以完成
但是python却不需要 通过垃圾回收机制自动管理
"""
垃圾回收机制原理分析
Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率。
1.引用计数
1.1引用计数算法原理
引用计数原理比较简单：
- 每个对象有一个整型的引用计数属性。用于记录对象被引用的次数。
- 例如对象A，如果有一个对象引用了A，则A的引用计数+1。
- 当引用删除时，A的引用计数-1。
- 当A的引用计数为0时，即表示对象A不可能再被使用，直接回收。
name = 'qyf' 数据值qyf身上的引用计数为1
name1 = name 数据值qyf身上的引用计数加1 为2
del name1 数据值qyf身上的引用计数减1 为1
当数据值身上的引用计数为0的时候 就会被垃圾回收机制当做垃圾回收掉
当数据值身上的引用计数不为0的时候 永远不会被垃圾回收机制回收
1.2 计数器增减条件
上面我们看到，创建一个A对象，并将对象赋值给a变量后，对象的引用计数器值为2。那么什么时候计数器会+1，什么时候计数器会-1呢？
1.2.1 引用计数+1的条件
- 对象被创建，如A()。
- 对象被引用，如a=A()。
- 对象作为函数的参数，如func(a)。
- 对象作为容器的元素，如arr=[a,a]。
1.2.2 引用计数-1的条件
- 对象被显式销毁，如del a。
- 变量重新赋予新的对象，例如a=0。
- 对象离开它的作用域，如func函数执行完毕时，func函数中的局部变量（全局变量不会）。
- 对象所在的容器被销毁，或从容器中删除对象。
2.标记清除
容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记清除”计数就是为了解决循环引用的问题。
主要针对循环引用问题
l1 = [11, 22] # 引用计数为1
l2 = [33, 44] # 引用计数为1
l1.append(l2) # l1 = [11, 22, l2列表] 引用计数为2
l2.append(l1) # l2 = [33, 44, l1列表] 引用计数为2
del l1 # 断开变量名l1与列表的绑定关系 引用计数为1
del l2 # 断开变量名l2与列表的绑定关系 引用计数为1
当内存占用达到临界值的时候 程序会自动停止 然后扫描程序中所有的数据
并给只产生循环引用的数据打上标记 之后一次性清除
3.分代回收
分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：
分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）
新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。也就是等级（代）越高，被垃圾回收机制扫描的频率越低
流程控制
流程控制理论
流程控制>>>:控制事物的执行流程
事物执行流程总共可以分为三种
1.顺序结构
从上往下依次执行 我们之前所编写的代码都属于该结构
2.分支结构
事物的执行会根据条件的不同做出不同的执行策略
3.循环结构
事物的执行会根据某个条件出现重复
ps:在代码的世界里 很多时候可能会出现三者混合
流程控制必备知识
1.python中使用代码的缩进来表示代码的从属关系
从属关系:缩进的代码(子代码)是否执行取决于上面没有缩进的
2.并不是所有的代码都可以拥有缩进的代码(子代码)
if关键字
3.如果有多行子代码属于同一个父代码 那么这些子代码需要保证相同的缩进量
4.python中针对缩进量没有具体的要求 但是推荐使用四个空格(windows中tab键)
5.当某一行代码需要编写子代码的时候 那么这一行代码的结尾肯定需要冒号
6.相同缩进量的代码彼此之间平起平坐 按照顺序结构依次执行
流程控制之分支结构
1.单if分支结构
if 条件:
条件成立之后才会执行的代码块
ps:单if可以借助于流程图理解
username = input('username>>>:')
if username == 'jason':
print('老师好')
2.if...else...分支结构
if 条件:
条件成立之后执行的子代码
else:
条件不成立执行的子代码
username = input('username>>>:')
if username == 'jason':
print('老师好')
else:
print('去你妹的')
3.if...elif...else分支结构
if 条件1:
条件1成立之后执行的子代码
elif 条件2:
条件1不成立 条件2成立执行的子代码
elif 条件3:
条件1和2都不成立 条件3成立执行的子代码
else:
上述条件都不成立 执行的子代码
ps:中间的elif可以写多个、上述子代码永远只会走一个
score = input('请输入学生成绩>>>:')
score = int(score) # 将字符串的整数转换成整型的整数
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('一般')
elif score >= 60:
print('及格')
else:
print('挂科 交钱重修')
4.if的嵌套使用
age = 28
height = 170
weight = 110
is_beautiful = True
is_success = False
username = 'tony'
if username == 'tony':
print('tony发现目标')
if age < 30 and height > 160 and weight < 150 and is_beautiful:
print('大妹纸 手机掏出来 让我加微信')
if is_success:
print('吃饭 看电影 天黑了...')
else:
print('去你妹的 流氓!!!')
else:
print('不好意思 认错人了')
else:
print('不是tony做不出来这件事')
流程控制之循环结构
1.流程控制之while循环
就是想让一些代码反复的执行
while 条件:
条件成立之后执行的子代码(循环体代码)
1.先判断条件是否成立
2.如果成立则执行循环体代码
3.循环体代码执行完毕后再次回到条件判断处 判断条件是否成立
4.如果成立 则继续执行循环体代码
5.按照上述规律依次执行 直到条件不成立才会结束循环体代码的执行
count = 1 #计数为1
while count < 5: # 判断计数是否小于5 成立则执行循环体代码
print('hello world') # 打印出hello world
count += 1 # count = count + 1 # 计数加1后返回条件判断处 判断条件是否成立 直至条件不成立才结束循环体代码
print('想不想干饭?') # 当循环体代码结束后才打印出想不想干饭
break # 强行结束循环体
while循环体代码一旦执行到break会直接结束循环
continue # 直接跳到条件判断处
while循环体代码一旦执行到continue会结束本次循环 开始下一次循环
while 条件:
循环体代码
else:
循环体代码没有被强制结束的情况下 执行完毕就会执行else子代码
1.1死循环
真正的死循环是一旦执行 CPU功耗会急速上升 直到系统采取紧急措施
尽量不要让CPU长时间不间断运算
1.2嵌套及全局标志位
强调:一个break只能结束它所在的那一层循环
强调:有几个while的嵌套 想一次性结束 就应该写几个break
is_flag = True
while is_flag:
username = input('username>>>:')
password = input('password>>>:')
if username == 'jason' and password == '123':
while is_flag:
cmd = input('请输入您的指令>>>:')
if cmd == 'q':
print('正在执行您的指令:%s' % cmd)
break # 结束小循环
break # 结束大循环
else:
print('用户名或密码错误')
强调:如果不想反复写break 可以使用全局标志位
# 全局标志位
is_flag = True
while is_flag:
username = input('username>>>:')
password = input('password>>>:')
if username == 'jason' and password == '123':
while is_flag:
cmd = input('请输入您的指令>>>:')
if cmd == 'q':
is_flag = False # 适用于一次能够更改全部循环判定条件
print('正在执行您的指令:%s' % cmd)
else:
print('用户名或密码错误')
2.流程控制之for循环
for循环能够做到的事情while都可以做到 只不过for循环在一些场景下使用更简单
主要场景为:循环获取存储多个数据的数据内部数据值
for循环语法结构：
for 变量名 in 待遍历的数据:
循环体代码
for循环特点：
1.擅长遍历取值
2.不需要结束条件 自动结束(遍历完)
for循环主要遍历的数据类型有(常见有 字符串、列表、元组、字典、集合)
info = 'hello world'
for i in info:
print(i) # 单个单个字符
d = {'username': 'jason', 'password': 123}
for i in d:
print(i) # 只有键参与遍历
for循环命名
for循环语法结构中的变量名如何命名：
1.见名知意
2.如果遍历出来的数据值没有具体的含义 可以使用常用的
i j k item v
for循环体代码中如果执行到break也会直接结束整个for循环
for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
for 变量名 in 待遍历的数据:
for循环体代码
else:
for循环体代码没有被break强制结束的情况下运行完毕之后 运行
range基本使用
用法：
range(num) # 0到num-1
range(num1,num2) # num1到num2-1
range(num1,num2,num3) # num1到num2-1 num3为差值
eg：for i in range(1,10,2) 则取到的为1 3 5 7 9
#从头到尾，但不会循环最后一位。顾头不顾尾
range可以简单的理解为是帮我们产生一个内部含有多个数字的数据
for i in range(101): # 起始位置为0 终止位置为100
print(i) # [0,.......100]
for i in range(10, 20): # 第一个为起始位置 第二个终止位置
print(i)
for i in range(1, 20, 2): # 第三个数为等差值 默认不写为1
print(i)
"""
在python2中
range()
直接产生一个列表 内部含有多个数值
xrange()
其实就是python3里面的range
在python3中
range()
类似于一个工厂 不会占用太多的内存空间 要就生产
"""
实战案例:
网络爬虫
使用代码爬取网络上我们需要的数据
项目需求
爬取所有页面的数据(博客园)
找寻规律
https://www.cnblogs.com/
https://www.cnblogs.com/#p2
https://www.cnblogs.com/#p3
https://www.cnblogs.com/#p4
大胆猜测:第一页是 https://www.cnblogs.com/#p1
编写代码产生博客园文章前两百页的网址
url = "https://www.cnblogs.com/#p%s"
for i in range(1,201):
print("url % i")
'''
分页的规律 不同的网址有所区别
1.在网址里面有规律
2.内部js文件动态加载
'''
数据类型内置方法与操作
整型内置方法与操作int
1.类型转换
int（其他数据类型）
ps：浮点型可以直接转 字符串必须满足内部是纯数字才可以
a = int(11.11) # 11
a = int(11.57) # 11
a = int('11') # 11
a = int('11.11') # 字符串中必须是纯数字才可以转 否则报错
2.进制数转换
十进制转其他进制
print(bin(23)) # 0b10111
print(oct(23)) # 0o27
print(hex(23)) # 0x17
'''
数字的开头如果是0b则为二进制 0o则为八进制 0x则为十六进制
'''
其他进制转十进制
print(int(0b10111)) # 23
print(int(0o27)) # 23
print(int(0x17)) # 23
字符串进制数转十进制
print(int("0b1100100", 2)) # 100
print(int("0o144", 8)) # 100
print(int("0x64", 16)) # 100
3.python自身对数字的敏感度较低(精确度低)
python这门语言其实真的一点都不厉害 主要是因为它背后有太多大佬
如果需要进准的计算需要借助于模块numpy.....
s1 = 1.1
s2 = 1
print(s1 - s2)
浮点型内置方法与操作float
1.类型转换
float(其他数据类型)
字符串里面可以允许出现一个小数点 其他都必须是纯数字
res = float(11) # 11.0 <class 'float'>
res = float('11') # 11.0 <class 'float'>
res = float('11.11') # 11.11 <class 'float'>
res = float('1.1.1.1') # 报错ValueError: could not convert string to float: '1.1.1.1'
res = float('abc') # 报错could not convert string to float: 'abc'
print(res, type(res))
2.python自身对数字的敏感度较低(精确度低)
python这门语言其实真的一点都不厉害 主要是因为它背后有太多大佬
如果需要进准的计算需要借助于模块numpy.....
字符串内置方法与操作str
1.类型转换
str(其他数据类型)
ps:可以转任意数据类型(只需要在前后加引号即可)
2.常用方法
2.1索引取值(起始位置0开始 超出范围直接报错)
s1 = 'helloworld'
print(s1[0]) # h
print(s1[-1]) # d 支持负数 从末尾开始
2.2切片操作
print(s1[1:5]) # 顾头不顾尾 从索引1一直切取到索引4
print(s1[-1:-5]) # 默认的顺序是从左往右 虽然不会报错但并不会打印出想要的结果
print(s1[-5:-1]) # 默认的顺序是从左往右 倒数第五个到倒数第二个 worl
2.3修改切片方向(间隔)
print(s1[1:5:1]) # 步长默认是1 从索引1开始一步一步一直切取到索引4 运行ello
print(s1[1:5:2]) # 步长改为2 从索引1开始到索引4 每个索引值步长差为2 运行el
print(s1[-1:-5:-1]) # 修改了顺序 从末尾索引-1开始步长为-1到索引-4 运行dlro
print(s1[:]) # 不写数字就默认都要 运行helloworld
print(s1[2:]) # 从索引2开始往后都要 运行lloworld
print(s1[:5]) # 从索引0开始往后要到4 运行hello
print(s1[::2]) # 全都要但步长为2 运行hlool
2.4统计字符串中字符的个数
len()返回字符串、列表、字典、元组等长度。
print(len(s1)) # 10
2.5移除字符串首尾指定的字符
strip() 方法用于移除字符串头尾指定的字符
括号内不写 默认移除首尾的空格
username = input('username>>>:').strip()
# username = username.strip() # 这个步骤可以省略直接在输入用户名的时候就可以移除首尾误打的空格符号
if username == 'jason':
print('登录成功')
res = ' jason ' # 首尾各有两个空格字符个数9
print(len(res)) # 字符个数9
print(len(res.strip())) # 去除了首尾的空格后字符个数5
res1 = '$$jason$$'
print(res1.strip('$')) # jason 去除首尾$字符
print(res1.lstrip('$')) # jason$$ lstrip去除左边的$字符
print(res1.rstrip('$')) # $$jason rstrip去除右边的$字符
2.6切割字符串中指定的字符
split()可以对任意string型的字符串，文字，按照指定的规则（文字，符号等）进行分割，并返回list值。
res = 'jason|123|read'
print(res.split('|')) # ['jason', '123', 'read'] 该方法的处理结果是一个列表
name, pwd, hobby = res.split('|')
print(res.split('|', maxsplit=1)) # ['jason', '123|read'] 从左往右切指定个数
print(res.rsplit('|', maxsplit=1)) # ['jason|123', 'read'] 从右往左切指定个数
2.7字符串格式化输出
format()格式化输出把传统的%替换为{}来实现格式化输出
format玩法1:等价于占位符
res = 'my name is {} my age is {}'.format('jason', 123)
print(res) # my name is jason my age is 123
format玩法2:索引取值并支持反复使用
res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
print(res) # my name is jason my age is 123 jason jason 123
format玩法3:占位符见名知意
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1} '.format(name1='jason', age1=123) # 跟索引取值异曲同工 不同就是见名知意
print(res)
format玩法4:推荐使用(******)
推荐使用不用提前定义好数值，当情况而定自定义数值
name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'
print(res)
3.需要了解的方法
3.1大小写相关
upper()作用于字符串中的小写字母转为大写字母。
lower()将字符串中的所有大写字母转换为小写字母
res = 'hElLO WorlD 666'
print(res.upper()) # HELLO WORLD 666 字符串全部转换成大写
print(res.lower()) # hello world 666 全部全部转转换成小写
'''图片验证码:生成没有大小写统一的验证码 展示给用户看
获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
'''
code = '8Ja6Cc'
print('展示给用户看的图片验证码', code)
confirm_code = input('请输入验证码').strip()
if confirm_code.upper() == code.upper(): # 将输入的验证码和当初产生的验证码统一转大写或者小写比对
print('验证码正确')
else:
print('验证码错误')
res = 'hello world'
print(res.isupper()) # 判断字符串是否是纯大写 False
print(res.islower()) # 判断字符串是否是纯小写 True
3.2判断字符串中是否是纯数字
isdigit()方法检测字符串是否只由数字组成，只对 0 和 正数有效。
如果字符串只包含数字则返回 True 否则返回 False
res = '0'
print(res.isdigit()) # True
guess_age = input('guess_age>>>:').strip() # 输入年龄 并移除首尾误打出的空格
if guess_age.isdigit(): # 判断输入的年龄是否是纯数字
guess_age = int(guess_age) # 条件成立 将输入的数值转换成整型
else:
print('年龄都不知道怎么输吗???')
3.3替换字符串中指定的内容
Replace()是把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
res = 'my name is qyf qyf qyf qyf qyf qyf'
print(res.replace('qyf', '666')) # my name is 666 666 666 666 666 666
print(res.replace('qyf', '333', 3)) # my name is 333 333 333 qyf qyf qyf 从左往右替换指定个数内容 从左往右替换指定个数内容
3.4字符串的拼接
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
ss1 = 'hello'
ss2 = 'world'
print(ss1 + '$$$' + ss2) # hello$$$world
print(ss1 * 10) # hellohellohellohellohellohellohellohellohellohello
print('|'.join(['jason', '123', 'read', 'JDB'])) # jason|123|read|JDB
print('|'.join(['jason', 123])) # 参与拼接的数据值必须都是字符串 否则会报错！！！
3.5统计指定字符出现的次数
count()统计在字符串/列表/元组中某个字符出现的次数，可以设置起始位置或结束位置。
res = 'hello world lalla'
print(res.count('l')) # 6
print(res.count('l', 4)) # 4
print(res.count('l', 5, 13)) # 2
3.6判断字符串的开头或者结尾
startswith()判断字符串是否以指定字符或子字符串开头
endswith()用于判断字符串中某段字符串是否以指定字符或子字符串结尾
res = 'jason say hello'
print(res.startswith('jason')) # True
print(res.startswith('j')) # True
print(res.startswith('jas')) # True
print(res.startswith('a')) # False
print(res.startswith('son')) # False
print(res.startswith('say')) # False
print(res.endswith('o')) # True
print(res.endswith('llo')) # True
print(res.endswith('hello')) # True
3.7其他方法补充
title( )返回'标题化'的字符串，就是单词的开头为大写，其余为小写
capitalize()它以大写形式返回字符串其中句子的第一个字符为大写其余字符为小写
swapcase()用于对字符串的大小写字母进行转换
index()用于从列表中找出某个值第一个匹配项的索引位置 如果没有找到对象则抛出异常
find()函数就是实现检索字符串，并且输出运算值,没有的直接返回-1
res = 'helLO wORld hELlo worLD'
print(res.title()) # Hello World Hello World
print(res.capitalize()) # Hello world hello world
print(res.swapcase()) # HELlo WorLD HelLO WORld
print(res.index('O')) # 4
print(res.find('O')) # 4
print(res.index('c')) # 找不到直接报错
print(res.find('c')) # 找不到默认返回-1
print(res.find('LO')) # 3
列表内置方法与操作list
1.类型转换
list(其他数据类型)
ps:能够被for循环的数据类型都可以转成列表
print(list('hello'))
print(list({'name': 'jason', 'pwd': 123}))
print(list((1, 2, 3, 4)))
print(list({1, 2, 3, 4, 5}))
2.需要掌握的方法
2.1索引取值(正负数)
11 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l1[0]) # 111
print(l1[-1]) # 888
2.2切片操作 与字符串讲解操作一致
print(l1[0:5]) # [111, 222, 333, 444, 555]
print(l1[:]) # [111, 222, 333, 444, 555, 666, 777, 888] 全都要
2.3间隔数 方向 与字符串讲解操作一致
print(l1[::-1]) # [888, 777, 666, 555, 444, 333, 222, 111] 更改方向并全都要
2.4统计列表中数据值的个数
print(len(l1)) # 8
2.5数据值修改
l1[0] = 123
print(l1) # [123, 222, 333, 444, 555, 666, 777, 888]
2.6列表添加数据值
方式1:尾部追加数据值
l1.append('干饭')
print(l1) # [111, 222, 333, 444, 555, 666, 777, 888, '干饭']
l1.append(['jason', 'kevin', 'jerry'])
print(l1) # [111, 222, 333, 444, 555, 666, 777, 888, ['jason', 'kevin', 'jerry']]
方式2:任意位置插入数据值
insert()可将给定元素插入列表中的给定索引
l1.insert(0, 'jason')
print(l1) # ['jason', 111, 222, 333, 444, 555, 666, 777, 888]
l1.insert(1, [11, 22, 33, 44])
print(l1) # [111, [11, 22, 33, 44], 222, 333, 444, 555, 666, 777, 888]
方式3:扩展列表 合并列表
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
print(ll1 + ll2) # [11, 22, 33, 44, 55, 66]
extend()函数主要是用于在列表末尾一次性追加另一个序列中的多个值(即用新列表扩展原来的列表)。
ll1.extend(ll2) # for循环+append
print(ll1) # [11, 22, 33, 44, 55, 66]
for i in ll2:
ll1.append(i)
print(ll1) # [11, 22, 33, 44, 55, 66]
2.7删除列表数据
方式1:通用的删除关键字del根据索引删除；删除索引范围内的元素；删除整个列表。
del l1[0]
print(l1) # [222, 333, 444, 555, 666, 777, 888]
方式2:remove根据元素检索删除；删除第一个出现的对应元素；确定列表种有某个元素，删除它
l1.remove(444) # 括号内填写数据值
print(l1) # [111, 222, 333, 555, 666, 777, 888]
方式3:pop()将列表指定位置的元素移除，同时可以将移除的元素赋值给某个变量
l1.pop(3) # 括号内填写索引值
print(l1) # [111, 222, 333, 555, 666, 777, 888]
l1.pop() # 默认尾部弹出数据值
print(l1) # [111, 222, 333, 444, 555, 666, 777]
res = l1.pop(3)
print(res) # 444
res1 = l1.remove(444)
print(res1) # None
2.8排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort() # 默认是升序
print(ss) # [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]
ss.sort(reverse=True) # 改为降序
print(ss) # [100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
2.9统计列表中某个数据值出现的次数
print(l1.count(111)) # 1
2.10颠倒列表顺序
l1.reverse() # reverse是python一个列表的内置函数,是列表独有的,用于列表中数据的反转,颠倒
print(l1) # [888, 777, 666, 555, 444, 333, 222, 111]
字典内置方法与操作dict
1.类型转换
dict()
字典的转换一般不使用关键字 而是自己动手转
2.字典必须要掌握的操作
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
2.1按k取值(不推荐使用)
print(user_dict['username']) # jason
print(user_dict['phone']) # k不存在会直接报错
2.2按内置方法get取值(推荐使用)
print(user_dict.get('username')) # jason
print(user_dict.get('age')) # None
print(user_dict.get('username', '没有哟 嘿嘿嘿')) # jason 键存在的情况下获取对应的值
print(user_dict.get('phone', '没有哟 嘿嘿嘿')) # 键不存在默认返回None 可以通过第二个参数自定义
2.3修改值数据
print(id(user_dict))
user_dict['username'] = 'tony' # 键存在则修改对应的值
print(id(user_dict))
print(user_dict) # 不可变类型 值改变 内存地址不变
2.4新增键值对
user_dict['age'] = 18 # 键不存在则新增键值对
print(user_dict)
2.5删除数据
del user_dict['username'] # 删除usenrname的键值对
print(user_dict) # {'password': 123, 'hobby': ['read', 'music', 'run']}
res = user_dict.pop('password') # 弹出password的对值与res绑定
print(user_dict) # {'hobby': ['read', 'music', 'run']}
print(res) # 123
2.6统计字典中键值对的个数
print(len(user_dict)) # 3
2.7字典三剑客
print(user_dict.keys()) # 一次性获取字典所有的键 dict_keys(['username', 'password', 'hobby'])
print(user_dict.values()) # 一次性获取字典所有的值 dict_values(['jason', 123, ['read', 'music', 'run']])
print(user_dict.items()) # 一次性获取字典的键值对数据 dict_items([('username', 'jason'), ('password', 123), ('hobby', ['read', 'music', 'run'])])
for i in user_dict.items():
k, v = i
print(k, v)
补充说明
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123)) # 快速生成值相同的字典
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res) # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('jason')
res['pwd'].append(123)
res['hobby'].append('study')
print(res) # {'name': ['jason', 123, 'study'], 'pwd': ['jason', 123, 'study'], 'hobby': ['jason', 123, 'study']}
'''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
res = user_dict.setdefault('username','tony')
print(user_dict, res) # 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age',123)
print(user_dict, res) # 存不存在则新增键值对 结果是新增的值
user_dict.popitem() # 弹出键值对 后进先出
popitem() 方法返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常
元组内置方法与操作tuple
1.类型转换
tuple()
ps:支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
2.1索引取值
print(l1[2]) # 33
2.2切片操作
print(l1[2:4]) # (33, 44)
2.3间隔、方向
print(l1[0:5:2]) # (11, 33, 55)
2.4统计元组内数据值的个数
print(len(t1)) # 6
2.5统计元组内某个数据值出现的次数
print(t1.count(11))
2.6统计元组内指定数据值的索引值
print(t1.index(22))
2.7元组内如果只有一个数据值那么逗号不可少
2.8元组内索引绑定的内存地址不能被修改
2.9元组不能新增或删除数据
集合内置方法与操作set
1.类型转换
set()
集合内数据必须是不可变类型（整型 浮点型 字符串 元组）
集合内数据也是无序的 没有索引概念
2.集合需要掌握的方法
去重
关系运算
ps:只有遇到上述两种需求的时候才应该考虑使用集合
3.去重
s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l1 = list(s1)
print(l1) # [33, 11, 22]
4.关系运算
群体直接做差异化校验
eg：两个微信账户直接 有不同的好友 有相同的好友
f1 = {'jason', 'tony', 'jerry', 'oscar'} # 用户1的好友列表
f2 = {'jack', 'jason', 'tom', 'tony'} # 用户2的好友列表
1.求两个人的共同好友
print(f1 & f2) # {'jason', 'tony'}
2.求用户1独有的好友
print(f1 - f2) # {'jerry', 'oscar'}
3.求两个人所有的好友
print(f1 | f2) # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
4.求两个人各自独有的好友
print(f1 ^ f2) # {'oscar', 'tom', 'jack', 'jerry'}
5.父集 子集
print(f1 > f2) # False
print(f1 < f2) # False
可变类型与不可变类型
s1 = '$$jason$$'
l1 = [11, 22, 33]
s1.strip('$')
print(s1) # $$jason$$
res = s1.strip('$')
print(res) # jason
'''
字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果
如何查看调用方法之后有没有新的结果 可以在调用该方法的代码左侧添加变量名和赋值符号
'''
ret = l1.append(44)
print(l1) # [11, 22, 33, 44]
print(ret) # None
'''列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果'''
可变类型:值改变 内存地址不变
# l1 = [11, 22, 33]
# print(l1)
# print(id(l1)) # 2180443267776
# l1.append(44)
# print(l1)
# print(id(l1)) # 2180443267776
不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'
print(res) # $$hello world$$
print(id(res)) # 2177293876720
res1 = res.strip('$')
print(res) # hello world
print(id(res)) # 2177298789552
字符编码
理论
该知识点理论特别多 但是结论很少 代码使用也很短
1.字符编码只针对文本数据
2.回忆计算机内部存储数据的本质
3.既然计算机内部只认识01 为什么我们却可以敲出人类各式各样的字符
肯定存在一个数字跟字符的对应关系 存储该关系的地方称为>>>:字符编码本
4.字符编码发展史
4.1.一家独大
计算机是由美国人发明的 为了能够让计算机识别英文
需要发明一个数字跟英文字母的对应关系
ASCII码:记录了英文字母跟数字的对应关系
用8bit(1字节)来表示一个英文字符
4.2.群雄割据
中国人
GBK码:记录了英文、中文与数字的对应关系
用至少16bit(2字节)来表示一个中文字符
很多生僻字还需要使用更多的字节
英文还是用8bit(1字节)来表示
日本人
shift_JIS码:记录了英文、日文与数字的对应关系
韩国人
Euc_kr码:记录了英文、韩文与数字的对应关系
"""
每个国家的计算机使用的都是自己定制的编码本
不同国家的文本数据无法直接交互 会出现"乱码"
"""
4.3.天下一统
unicode万国码
兼容所有国家语言字符
起步就是两个字节来表示字符
utf系列:utf8 utf16 ...
专门用于优化unocide存储问题
英文还是采用一个字节 中文三个字节
字符编码实操
1.针对乱码不要慌 切换编码慢慢试即可
2.编码与解码
编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
字符串.encode()
解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
bytes类型数据.decode()
3.python2与python3差异
python2默认的编码是ASCII
1.文件头
# encoding:utf8
2.字符串前面加u
u'你好啊'
python3默认的编码是utf系列(unicode)