周结2
周总结
目录
-
数据类型
1、数据类型之整型(int)及内置方法和操作
整型意思就是整数，如：一个人的年龄、班级人数、年月日
# 1.类型转换：int(其他数据类型)
在做数据类型转换的时候 只能转换纯数字
浮点型可以直接转 字符串必须满足内部是纯数值才可以(字符串纯数字但是如果带小数点也不能识别)
l1 = '123'
l1 = int(l1)
print(type(l1)) # int
print(int('1.23')) # 报错 不识别小数点
print(int(12.5)) # 12 不看小数点以后的数
print(int('jason123')) # 不识别除数字以外的数据
# 2.进制数转换
print(bin(100)) # 十进制数转二进制
print(oct(100)) # 十进制数转八进制
print(hex(100)) # 十进制数转十六进制
如果数字是以0b开头则为二进制、0o开头则为八进制、0x开头则为十六进制
# 3.精确度低
对数字敏感度较低 如果需要准确计算需要借助模块的numpy....
l1 = 1.1
l2 = 1
print(l1 - l2) # 0.1000000009
2、数据类型之浮点型(float)及内置方法和操作
浮点型就是小数，如：人的身高、体重、薪资
# 类型转换：float(其他数据类型)
print(float('123')) # 123.0
print(float('12.3')) # 12.3
字符串里可以出现一个小数点、其他必须是纯数字
3、数据类型之字符串(str)及内置方法和操作
字符串意思就是文本类的数据，引号引起来的部分就是字符串 如：姓名、地址、爱好
# 类型转换：str(任意数据类型)
# 索引取值
起始位置0开始 超出范围会直接报错
res = 'hello world' 空格也是字符
print(res[0]) # h
# 切片操作
print(res[1:5]) # ello 顾头不顾尾
print(res[-1]) # d
print(res[-5]) # w
print(res[-5:]) # world
print(res[-1:-5])
# 修改切片方向(间隔)
print(res[1:5:1]) # ello 默认是1
print(res[1:5:2]) # el 间隔是1
print(res[-1:-5:-1]) # dlro 更改了方向
# 统计字符串中字符个数
print(len(res)) # 11
# 移除字符串首尾指定的字符
.strip()
# 切割字符串指定的字符
res = 'jason|123|read'
print(res.split('|')) # ['jason', 123, 'read'] 该方法处理出来的的是一个列表
print(res.split('|', maxsplit=1)) # ['jason', '123|read'] 从左往右切指定的个数
print(res.rsplit('|', maxsplit=1)) # ['jason|123', 'read'] 从右往左切指定的个数
# 字符串格式化输出
format方法一：等价于占位符
res1 = 'my name is {} my age is {}'.format('jason',123) # my name is jason my age is 123
format方法二：索引取值并支持反复使用
res2 = 'my name is {0} {1} my age is {1} {0}'.format('jason', 123) # my name is jason 123 my age is 123 jason
format方法三：占位符见名知意
res3 = 'my name is {name} my age is {age} {name} {age}'.format(name='jason', age=123) # my name is jason my age is 123 jason 123
format方法四：推荐使用
name = input('请输入你的名字>>>:')
age = input('请输入你的年龄>>>:')
l3 = f'my name is {name} my age is {age}'
# 大小写相关
upper 大写
lower 小写
# 判断是否纯数字
.isdigit()
res = 'jason123'
print(res.isdigit()) # Flase
# 替换字符串中指定的内容
l1 = 'my name is jason my age is tony jason'
print(l1.replace('jason', 'tony')) # my nameis tony my age is tony tony
从左往右指定替换个数print(l1.replace('jason', 'oscar', 1)) # my name is oscar my age is tony jason
# 字符串的拼接
name1 = jason
name2 = tony
直接相加：print(name1 + name2) # jasontony
print(name1 + '|' + name2) # jason|tony
print(name1*3) # jasonjasonjason
join拼接用法：参与拼接的数据值必须是字符串类型
print(''.join(['jason', '123', 'read'])) # jason123read
# 统计字符出现的次数
l1 = 'hello world'
print(l1.count('l') # 3
# 判断字符串的开头或结尾
res = 'jason is big big'
print(res.startswith('jason')) # True 判断字符串是否以jason开头
print(res.endswith('big')) # True 判断是否以big结尾
# 其他方法补充
res = 'my name is Jason my friend is Tony'
title() # 开头首字母大写
print(res.title()) # My Name Is Jason My Friend Is Tony
capitalize() # 首字母大写其余都变小写
print(res.capitalize()) # My name is jason my friend is tony
swapcase() # 大小写互换
print(res.swapcase) # MY NAME IS jASON MY FRIEND IS tONY
index() # 查找字符位置
print(res.index('m')) # 0 从左往右找到一个就直接返回该字符所在的索引位置 找不到直接报错
find() # 查找字符位置
print(res.find('m')) # 0 从左往右依次查找
print(res.find('c')) # -1 找不到直接返回-1
4、数据类型之列表(list)的内置方法和操作
列表就是可以存储多个数据值的类型 且可以非常方便的取值
中括号括起来 内部可以存放多个数据值 值相互之间用逗号隔开 据值可以是任意数据类型
# 类型转换
list(其他数据类型) 能够被for循环的数据类型(字符串、字典、元组、集合)都可以转换成列表
# 索引取值
l1 = [11, 22, 33, 44, 55, 66]
print(l1[o]) # 11
# 切片、间隔、方向操作 与字符串一致
print(l1[-1]) # 66 索引-1代表最后一位
print(l1[-1:-2]) # [] 默认是从左往右第一个数索引-1已经是最后一位
print(l1[-2:-1]) # [55]
print(l1[-1:-2:-1]) # [66]
print(l1[0:3]) # [11, 22, 33, 44] 顾头不顾尾
print(l1[:]) # [11, 22, 33, 44, 55, 66]
print(l1[1:4]) # [22, 33, 44]
print(l1[1:4:2]) # [22, 44] 第三个数表示间隔默认是1
# 统计列表中数据值的个数
res = [0, 11, 22, 33, 44, 55, 66]
print(len(res)) # 7
# 统计列表中某个数据值出现的次数
l1 = [11, 22, 33, 11, 22, 33]
print(l1.count(11)) # 2
# 数据值修改
res[0] = 99
print(res) # [99, 11, 22, 33, 44, 55, 66]
# 列表添加数据值
方式一：append 尾部追加(将括号内的数据值当做一个整体追加到列表末尾)
res = [0, 11, 22, 33, 44, 55, 66]
res.append(99)
print(res) # [0, 11, 22, 33, 44, 55, 66, 99]
方式二：insert 任意位置插入数据值(将括号内的数据值当做一个整体插入到索引指定位置)
res = [0, 11, 22, 33, 44, 55, 66]
res.insert(0, 'jaosn') # ['jason', 0, 11, 22, 33, 44, 55, 66]
方式三：扩展列表
l1 = [11, 22, 33]
l2 = [44, 55, 66]
print(l1 + l2) # [11, 22, 33, 44, 55, 66]
l1.extend(l2)
print(l1) # [11, 22, 33, 44, 55, 66]
extend相当于for循环加append操作
for i in l2:
l1.append(i)
print(l1) # [11, 22, 33, 44, 55, 66]
# 删除列表数据
方式一：通用的删除关键字del
num = [22, 33, 44, 55, 66]
del num[0]
print(num) # [22, 33, 44, 55, 66]
方式二：remove() 在括号内直接填写数据值
num = [22, 33, 44, 55, 66]
num.remove(22)
print(num) # [33, 44, 55, 66]
方式三：pop() 在括号内直接填写索引值
num = [22, 33, 44, 55, 66]
num.pop(3)
print(num) # [22, 33, 44, 66]
print(num.pop(3)) # 55 能够弹出索引的值
num1 = [22, 33, 44, 55, 66]
print(num1.pop(0)) # 22
print(num1.remove(33)) # None
# 排序
i = [22, 54, 67, 12, 45, 67, 13, 62]
i.sort() # 默认是升序
print(i) # [12, 13, 22, 45, 54, 62, 67, 67]
i.sort(reverse=True) # 改为降序
print(i) # [67, 67, 62, 54, 45, 22, 13, 12]
# 颠倒列表顺序
i = [22, 54, 67, 12, 45, 67, 13, 62]
i.reverse()
print(i) # [62, 13, 67, 45, 12, 67, 54, 22]
5、数据类型之字典(dict)的内置方法和操作
能够精准的存储和表达数据值的含义
大括号括起来 内部可以存放多个数据值 数据值须是K:V键值对的形式 键值对之间用逗号隔开
K是对V的描述信息 K是字符串类型 而V才是真正的数据类型且可以是任意数据类型
按K来取值
字典里只能按K取值，字典里无序的，没有索引的概念
变量名[K]
# 类型转换
dict() 字典的转换一般不使用关键字 而是自己动手转
# 按键取值(不推荐使用)
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
print(dic['age']) # 18
print(dic['pwd']) # 键不存在直接报错
# 按内置方法get取值(推荐使用)
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
print(dic.get('username')) # jason
print(dic.get('age')) # None键不存在不会报错
print(dic.get('age', '哈哈哈')) # 18 键存在的情况下获取对应的值
print(dic.get('pwd', '哈哈哈')) # 哈哈哈 可以通过第二个参数自定义 键存在获取对应的值 不存在返回自定义的数值
# 修改数据值
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
print(id(dic)) # 2299181084464
dic['age'] = 99 # 键存在则修改对应的值
print(dic) # {'username': 'jason', 'age': 99, 'hobby': ['read', 'music', 'run']}
print(id(dic)) # 2299181084464
# 新增键值对
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
dic['password'] = 123
print(dic) # {'username': 'jason', 'age': 18, 'hobby': ['read', 'music', 'run'], 'password': 123}
# 删除数据
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
del dic['username']
print(dic) #{'age': 18, 'hobby': ['read', 'music', 'run']}
res = dic.pop('username') print(res) # jason
print(dic) # {'age': 18, 'hobby': ['read', 'music', 'run']}
# 统计字典中键值对的个数
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
print(len(dic)) # 3
# 字典三剑客
剑客一：一次性获取所有的键 可以看做是一个列表能支持for循环
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
print(dic.keys()) # dict_keys(['username', 'age', 'hobby'])
剑客二：一次性获取字典所有的值 可以看做是一个列表你能支持for循环
print(dic.values()) # dict_values(['jason', 18, ['read', 'music', 'run']])
剑客三：一次性获取字典所有的键值对数据 可以看做是列表套元组的形式
print(dic.items())
# dict_items([('username', 'jason'), ('age', 18), ('hobby', ['read', 'music', 'run'])])
for k, v in dic.items():
print(k, v)
打印出的是：
username jason
age 18
hobby ['read', 'music', 'run']
等价于：
for i in dic.items():
k, v = i
print(k, v)
# 快速生成值相同的字典
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123)) # {'name': 123, 'pwd': 123, 'hobby': 123}
'当第二个公共值是可变类型的时候 一定得注意通过一个的键修改 都会影响所有'
# 键存在则不修改 结果是键对应的值
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
res = dic.setdefault('username', 'tony')
print(res) # jason
# 键不存在则新增键值对 结果是新增的值
dic = {'username': 'jason', 'age' : 18, 'habby': ['read', 'run', 'music']}
res1= dic.setdefault('pwd', 123)
print(dic) # {'username': 'jason', 'age': 18, 'hobby': ['read', 'music', 'run'], 'pwd': 123}
print(res1) # 123
#弹出键值对 后进先出
print(dic.popitem()) # ('hobby', ['read', 'music', 'run'])
6、数据类型之元组(tuple)的内置方法和操作
也称不可变的列表 (用小括号括起来 内部可以存放多个数据值 数据值与数据值之间用逗号隔开 数据值可以是任意数据类型)
元组内索引绑定的内存地址不能被修改
元组不能新增或删除数据
元组内如果只有一个数据值逗号不能省略
# 类型转换
tuple() 支持for循环的数据类型都可以转成元组
# 索引取值
t1 = (11, 22, 33, 44, 55, 66)
print(t1[0]) # 11
# 切片操作
t1 = (11, 22, 33, 44, 55, 66)
print(t1[1:5]) # (22, 33, 44, 55)
# 间隔、方向
t1 = (11, 22, 33, 44, 55, 66)
print(t1[1:5:1]) # (22, 33, 44, 55)
print(t1[1:5:2]) # (22, 44)
print(t1[-5:-1]) # (22, 33, 44, 55)
print(t1[-1:-5]) # ()
print(t1[-1:-5:-1]) # (66, 55, 44, 33)
# 统计元组内数据值的个数
t1 = (11, 22, 33, 44, 55, 66)
print(len(t1)) # 6
# 统计元组内某数据值出现的次数
t1 = (11, 22, 33, 44, 55, 66)
print(t1.count(11)) # 1
# 查找元组内指定数据值的索引值
print(t1.index(11)) # 0
7、数据类型之集合(set)的内置方法和操作
大括号括起来 内部可以存放多个数据值 数据值与数据值之间用逗号隔开 数据值不是K:v键值
集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
集合内数据也是无序的 没有索引的概念
# 类型转换
set() 集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
# 去重
s1 = {11, 22, 33, 44, 22, 33, 11, 44, 55}
print(s1) # {33, 11, 44, 22, 55}
s2 = [22, 33, 55, 66, 33, 55, 33, 44, 22]
s3 = set(s2)
s2 = list(s3) # [33, 66, 44, 22, 55]
""""集合的去重无法保留原先数据的排列顺序"""
# 关系运算
群体之间做差异化校验
eg：两个QQ号之间做差异化校验
用户1好友列表：t1 = {'jason', 'tony', 'oscar', 'marry'}
用户2好友列表：t2 = {'jack', 'tony', 'oscar', 'tom'}
1、求两个人的共同
print(t1 & t2) # {'tony', 'oscar'}
2、求用户1独有的好友
print(t1 - t2) # {'marry', 'jason'}
3、求两个人所有的好友
print(t1 | t2) # {'jason', 'jack', 'tom', 'tony', 'marry', 'oscar'}
4、求两个各自独有的好友
print(t1 ^ t2) # {'marry', 'jason', 'jack', 'tom'}
5、父集 子集
print(t1 < t2) # False
print(t2 > t2) # False
-
垃圾回收机制
在内存中没有任何变量值指向的数据叫做垃圾
# 而针对垃圾数据在python中有一套回收的方案
1、引用计数
内存中变量值身上有几个变量名绑定的引用计数就是几 只要不为0就不是垃圾
2、标记清除
当内存即将沾满的时候 python会自动暂停程序的执行 从头到尾的将内存中数据进行扫描一遍 并打上标 之后再一次性清除掉标记的数据
3、分代回收
垃圾回收机制的频繁运行也会有损耗各项资源 会将数据的监管分为三个层次 随着层次的下降监管的频 率下降
-
流程控制
# 顺序结构
自上而下的依次运行
# 分支结构
在运行过程根据条件的不同可能会执行不同的流程
# 循环结构
在运行过程中有些代码需要反复运行
1、条件都会转化成布尔值从而决定子代码是否执行
2、在python中 使用缩进来表示代码的从属关系
3、并不是所有代码都可以拥有子代码
4、同属于某个代码的多行子代码 必须保持相同的缩进量 在python中通常使用4个空格来缩进
5、上一行代码的结尾如果是冒号 那么下一行必缩进
分支结构if
# 单if分支结构
if 条件：
条件成立之后执行的子代码
如果年龄小于18叫未成年
age = input('输入年龄>>>:')
age = int(age)
if age < 18:
print('未成年')
# if与else连用
if 条件：
条件成立执行的子代码
else:
条件不成立执行的子代码
if与else连用 两者的子代码永远只会执行一个
如果年龄小于18件叫未成年 否侧叫成年人
age = input('输入年龄>>>:')
age = int(age)
if age < 18 :
print('未成年')
else:
print('成年人')
# if elif else三者连用
if 条件1：
条件1成立执行的子代码
elif 条件2：
条件1不成立 条件2成立之后执行的子代码
elif 条件3：
条件1和2都不成立 条件3 成立之后执行的子代码
...(elif可以有多个)
else:
上述条件都不成立执行的子代码
'三者连用也只能执行其中一个子代码'
循环结构while
# whlie循环
while 条件：
条件成立之后循环的子代码
1、先判断条件是否成立
2、如果成立则执行循环替代码
3、循环体代码执行完毕后再次回到条件判断处 判断条件是否成立
4、如果条件成立 则继续执行循环体代码
5、按照上述规律依次执行 直到条件不成立才会结束循环体代码的执行
# while+break
break # 强行结束循环体代码
while循环体代码一旦执行到break会直接结束循环
# whlie+continue
continue # 直接跳到条件判断处
当while循环体代码一旦执行到continue会结束本次循环 开始下一次循环
while+else
while 条件：
循环体代码
else：
循环体代码没有被强制结束的情况下 则执行完毕就会执行else子代码
循环结构for
# for循环结构
for循环的能够做到的事情while都能做到 而for的循环语法更加简洁 并且在循环取值问题上更加方便
for 变量名 in 带遍历数据：
for循环体代码
for循环的特点：
1、擅长遍历取值
2、不需要结束条件 遍历完自动结束
for循环结构中的变量名如何命名：
1、见名知意
2、如果遍历出来的数据值没有具体意义 可以使用常用的 i j k item v 来指代变量名
for循环的主要遍历数据类型有(常见的有：字符串、列表、元组、字典、集合)
# for+break
在循环体代码中如果执行到break也会结束整个for循环
res = ['jason', 'kevin', 'oscer', 'marry']
for i in res:
if i == 'kevin':
break
# for+continue
在循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
res = ['jason', 'kevin', 'oscer', 'marry']
for k in res:
if k == 'oscer':
continue
print(k)
range方法
# range的三个使用方法
第一种：一个参数 从0开始 顾头不顾尾
for i in range(10):
print(i) # 打印出来的是0 1 2 3 4 5 6 7 8 9
第二种：两个参数 自定义起始位置 顾头不顾尾
for i in range(1, 10):
print(i) # 打印出来的是1 2 3 4 5 6 7 8 9
第三种：三个参数 第三个数字为等差值 默认不写为1
for i in range(1, 10, 2):
print(i) # 打印出来的是1 3 5 7 9
-
可变类型与不可变类型
可变类型：值改变 内存地址不变
不可变类型：值改变 内存地址肯定变
# 可变类型 >>> '''列表 字典 集合'''
res = [66, 99, 88]
print(res) # [66, 99, 88]
print(id(res)) # 2430719577480
res.append(11)
print(res) # [66, 99, 88, 11]
print(id(res)) # 2430719577480
值改变 内存地址不变 修改的是原值
# 不可变类型 >>> '''整型 浮点型 字符串 元组'''
l2 = '@@hello world@@'
print(l2) # @@hello world@@
print(id(l2)) # 1846569412592
l3 = l2.strip('@')
print(l3) # hello world
print(id(l3s)) # 1946783222576
值改变 内存地址肯定变 其实是产生了新值
-
python2与python3的差异
python2中input：
input 方法需要用户自己提前指定输入的数据——>用户自己写的是啥类型就是啥类型
raw_input 方法与python3中的input是一样的——>输入的都统一处理成字符串类型
python2中print:
print方法有两种方式：不加括号、加括号
print 数据值
print(数据值)
Python2中:
range() # 它产生的是一个列表 内部含有多个数值
xrange() # 其实就是python3中的range
python3中:
range() # 类似一个工厂 不会占用多大的空间 要的话就生产
python2与python3的差异
python2默认的编码是ASCII
1、文件头
encoding；utf8
2、字符串前面加u
u'哈哈哈'
python3默认的编码是utf系列()
-
字符编码
只跟文本文件和字符串有关 与视频文件 图片文件等无关
# 什么是字符编码？
由于计算机内部只识别二进制 但是用户在使用计算机的时候却可以看到各式各样的语言字符
# 发展史
1、一家独大
计算机最初是由美国人发明的 美国人为了能够让计算机识别英文字符
ASCII：里面记录了英文字符与数字的对应关系 用一个字节(8bit)来表示一个英文字符
2、群雄割据
中国人：
GBK码：记录了英文、中文与数字的对应关系
用至少16bit(2字节)来表示一个中文字符
很多生僻字还需要使用更多的字符
英文还是用8bit(一字节)来表示
日本人：
shift_JIS码记录了英文、日文与数字的对应关系
韩国人：
Eur_kr码记录了英文、韩文与数字的对应关系
"""
每个国家的计算机使用的都是自己定制的编码本
不同的国家的文本数据无法直接交互 都会出现——>乱码
"""
3、天下统一
uincode万国码：兼容所用国家语言 起步就是两个字节来表示字符
utf系列：utf8 utf16...专门用来优化unicode储存问题 英文还是采用1个字节 中文3个字节
# 编码与解码
编码：将人类字符按照指定的编码 编码成计算机能够读懂的数据
字符串.encode()
解码：将计算机能够读懂的数据按照指定的编码解码成人类能够读懂的
bytes类型数据.decode()
