Python学习笔记---第二周

1.整型
符号：int
用处：用于计算和比较
python3:全部都是整型
python2：整型，长整型long
123--十进制 转二进制方法：十进制数除2，取余数从下往上排；print(bin(十进制数))
10101--二进制 转十进制方法：1 * 2 ** 0+0 * 2 ** 1+1 * 2 ** 2+0 * 2 ** 3+1 * 2 **4 print（int("二进制数"，2))
2.布尔值
整型转布尔值==print(bool(数字)) ，整型中只要非零就是True
布尔值转整型==print(int(True/False)), 布尔值True=1,False=0
字符串转布尔值==print(bool(" ")), 字符串中只要没有内容就是False
布尔值转字符串==print(str(True/False))
3.字符串
python中只要是引号引起来的就是字符串
作用：用于存储少量数据
字符串中每一个字母或字符都称为元素
3.1 索引（下标）
符号：a[索引位置] -- 索引位置不能超出索引最大值

从左往右排，从0开始排；从右往左排，从-1开始排
3.2 切片
返回结果是原数据本身
print(a[起始位置：终止位置])-- 顾头不顾尾（包括起始位置，不包括终止位置）
索引位置可以超过索引值，索引位置不写时默认起始位置为第一位，终止位置为最后一位

3.3 步长
print(a[1:2:1])
默认为一，步长决定查找方向，决定查找时每次查找的长度（步长为正：从左往右；步长为负：从右往左）
[::-1] -- 将字符串进行反转
起始位置走向的方向不指向终止位置，取不到东西
3.4 字符串的方法
字符串是不可变数据类型，有序的
a.upper() -- 全部大写
a.lower() -- 全部小写
a.startswith("内容") -- 以什么开头，返回的是布尔值 print(" ",1,2) -- 1(起始位置) 2（终止位置）
a.endswith() -- 以什么结尾，返回的是布尔值
a.count(" ") -- 统计元素出现的次数
a.strip() --默认脱头尾两端的空格，换行符\n，制表符\t a.strip("脱去内容") -- 去除头尾两端的指定内容，如果有两个指定元素，每个元素去除一遍，合起来再去除一遍
a.split() -- 分割 ，默认分割空格，换行符，制表符 a.split(" ",2) --2(被分割的次数，从左往右)
a.replace("要被替换的内容"，"替换的内容") -- 全部替换 a.replace("被替换内容"，"替换内容"，1) -- 1（替换个数，从左往右）
3.5 字符串格式化
name = "{}今年{}".format(" "," " ) -- 按顺序填充
name = "{1}今年{0}".format(" "," ") -- 按索引填充
name = "{name}今年{age}".format(name=" ",age=" ") --按名字进行填充
3.6 is系列
用于判断
a.isdigit() -- 判断字符串中的内容是不是全都是数字（阿拉伯数字），返回布尔值
a.isdecimal() -- 判断是不是十进制数
a.isalnum() -- 判断是不是字母，数字，中文
a.isalpha() -- 判断是不是字母，中文
4.for循环
格式：for i in a:

​ 缩进print(i)
for --关键字
i -- 变量名（可任意修改）
in -- 关键字
a -- 可迭代对象（python数据类型中除了int 和布尔值，其余都能迭代）
for循环在循环的时候就已经进行了赋值

... -- 和pass功能一样

5.列表
符号：list
数据类型之一，存储大量的不同类型的数据，别的语言称为数组
列表是一种有序的容器，支持索引
列表是一种可变数据类型 -- 原地修改
字符串中只要占一个位置就是一个元素，列表中只要是逗号分隔的都是元素
格式lst = [" "," "] -- (用逗号隔开)

5.1 列表的增加
lst.append() --追加，在最末尾的地方进行添加

lst.insert(1，" ") -- 插入 1(索引位置，插在索引位置前) ----尽量少用，会导致效率变低

lst.extend() -- 迭代添加

5.2 列表的删除
lst.remove() -- 按元素的名字删除，只能删除第一个，从左往右删除

lst.pop() -- 弹出，默认删除最后一个，并且具有返回值，返回值为删除内容

lst.pop(1)-- 按索引删除，返回值字符串不带引号，repr()查看当前数据的原生态

lst.clear() -- 清空
del lst[1] -- 按索引删除
del lst[1:2] -- 按切片删除
del lst[1:2:1] -- 按步长删除
5.3 列表的修改
lst[2] = 80 --通过索引进行修改 2（索引位置） 80（替换的内容）

lst[1:2] -- 通过切片进行修改，默认步长为一，修改的内容必须是可迭代的对象，修改的内容可多可少，不能空（多的时候扩展位置，少的时候自动补位）

lst[1:2:2] -- 步长不为一的时候，被替换的内容和替换的内容数量要一致

5.4 列表的查找
for循环
索引
5.5 列表的嵌套
一层一层查找，[ ]-- 代表一个元素
6.元组
符号：tuple
格式：tu=(" ", " ")
python数据类型之一,有序的，不可变，相当于不可变的列表
只支持查：for循环
元组的方法：
统计 -- tu.count()

获取索引 -- tu.index() 通过元素查询索引

元组的用处：在配置文件中使用
元组的嵌套

7.范围
符号：range
range的诞生是为了解决不能循环数字
range是一个可迭代对象
print(range(1,10) )-- python3中打印range是自己本身

print range(1,10) --python2中打印range是列表
range(10) -- 10代表终止位置，起始位置默认为零，顾头不顾尾
range(1,10,1) -- 步长默认为一
8.字典
python数据结构之一
符号：dict
格式：dic={"key":"value"} -- 键值对 键必须是不可变的数据类型（可哈希），且唯一；值任意
字典是可变数据类型，无序的，所有操作都是通过键
8.1 字典的增加
dic["键"]="值" -- 添加键值对 暴力添加

dic.setdefault("键"，"值") -- 无则添加，有则不添加 内置步骤：1.先查看键是否在字典2.不存在的时候进行添加

8.2 字典的删除
dic.pop("键") -- 通过键删除，具有返回值，返回的是被删除的值

dic.clear() -- 清空
del dic -- 删除整个字典
del dic["键"] -- 通过键进行删除

8.3 字典的改
dic["键"]="值"，有则覆盖，没有就添加

dic.update(字典) --括号里的字典级别高于原字典

8.3 字典的查找
dic.get("键") -- 通过键获取值 ,只有键没有值时查询不到返回None；有键值对时返回值

dic.setdefault("键") -- 通过键获取值,查询不到返回None

dic["键"] -- 通过键获取值,查询不到就报错
dic.keys() -- 获取到的是高仿列表---键
dic.values() -- 获取到的是高仿列表---值
高仿列表支持迭代，不支持索引
list(dic.keys())--可转换成列表
通过for循环查
for i in dic
print(i) -- 查看所有的键

print(dic.get(i)) -- 查看所有的值

print(list(dic.items())) -- 查看所有键值对

for i in dic.items(): print(i[0],i[1])

8.4 字典的嵌套
嵌套查找时按照键一层一层找
常用数据类型：字典，列表，字符串，数字
9.解构
作用：省去使用下标


解构可用于元组，列表，字符串，字典，但应注意等号两边的元素个数要一致

for a,b in dic.items()

10.小数据池
== 判断两个值是否相等，is 是 -- 判断两边的内存地址是否相同
id()查看内存地址
小数据池支持的类型：int,str,bool
int: -5~256（范围）
str: 字母，数字 长度任意，符合驻留机制
规则：字符串（字母，数字）进行乘法时，总长度不能超过20
特殊符号（中文和符号）进行乘法的时候只能乘以0
11.代码块
一个py文件，一个函数，一个模块，终端(cmd)中每一行都是代码块
支持：int，str,bool
字符串：定义字符串的时候可以是任意的
规则：字符串（字母，数字）进行乘法时，总长度不能超过20
特殊符号（中文和符号）进行乘法的时候只能乘以0或者1
小数据池和代码块同在的时候先执行代码块
驻留机制：目的：节省内存空间，提升效率（减少了开辟空间和销毁空间的耗时）
12.集合
符号：set
格式：s={1,2,3,4}
集合就是一个没有值的字典 无序，可变，集合的元素是不可变的
天然去重：输出的元素没有重复的
集合的增
s=set() -- 空集合
s.add() -- 整个添加
s.update()/set() -- 迭代添加
set(" ") -- 迭代添加
删除
s.remove() -- 通过元素删除
s.clear() -- 清空
s.pop() --随机删除（最小的）
改
先删后加
查
for 循环
其他操作
s-s1 --差集

s&s1 --交集

s|s1 --并集

s^s1 -- 反交集

s>s1 -- 判断s1是不是s的子集
s<s1 -- 判断s1是不是s的父集（超集）
frozenset({1,2,3}) -- 冻结集合（变成不可变的）
13.深浅拷贝
格式：浅拷贝a[:]/a.copy() 深拷贝b=copy.deepcopy(a)
浅拷贝：
只拷贝第一层元素，只有修改第一层（不可变）的时候源数据不受影响
给可变数据类型添加的时候源数据会受影响
深拷贝
import copy (导入模板)
深拷贝：不可变数据类型共用，可变数据类型新开辟一个空间
赋值：将多个变量名指向同一个内存地址
14.基础数据类型补充
str
a.capitalize() -- 首字母大写
a.title() --每个单词首字母大写
a.swapcase --大小写转换
a.center(长度) -- 居中
a.center(长度，"填充内容") -- 填充
a.find("") -- 通过元素查找索引，查找不到返回-1
a.index("") -- 通过元素查找索引，查找不到报错
"拼接的元素".join([1,2,3]) -- 拼接，将列表转成字符串
字符串进行加和乘时都是开辟新空间
list
list("12345") -- 列表的另外一种定义
lst.index() --通过元素查找索引
lst.sort() -- 排序（默认升序）
lst.sort(reverse=True) -- 降序
lst.reverse() -- 反转




列表在进行乘法的时候,元素是共用的
元组（tuple)
tu=(1) 源数据类型
tu1=("alex") 源数据类型
tu2=(1,) 元组
tu3=() 元组

dict
dic.popitem() 随机删除 python3.6版删除最后一个键值对
popitem返回的是被删除的键值对
dic.fromkeys("abc",[]) # 批量创建键值对


fromkeys 第一个参数必须是可迭代对象,会将可迭代对象进行迭代,成为字典的键.第二个参数是值(这个值是共用的)
fromkeys 共用的值是可变数据类型就会有坑,不可变数据类型就没事
15.总结
可变，不可变，有序，无序
可变：list,dict,set
不可变：int,str,bool,tuple
有序：list,tuple,str
无序：dict,set
取值方式
索引：list,tuple,str
键：dict
直接：int,bool,set
数据类型转换
str -- int
int -- str
str -- bool
bool -- str
int -- bool
bool -- int
list -- tuple: list(tu)
tuple -- list: tuple(list)
list -- set: list(s)
set -- list
set -- tuple
tuple -- set
***重要：list -- str

str -- list

目前字典转换，自己实现方法
16.以后会遇到的坑
lst = [1,2,3]
for i in lst:
lst.append(4)
print(lst)
死循环，在加4的同时列表lst会一直增加

lst = [11,22,33,44]
for i in lst:
    lst.remove(i)
print(lst)
这段程序的目的是把列表里的数据全部删除，但列表和for具有自动补位，删掉11之后会22会补到11的位置，下次再删就是33，22和    44会跳过去

lst = [11,22,33,44]
for i in lst:
    del lst[-1]
print(lst)
这段程序从后面删除，删除到33的时候，程序会结束，会留下11和22

lst = [11,22,33,44]
for i in range(len(lst)):
   del lst[-1]
print(lst)
借用列表的长度循环，可以实现

for i in range(len(lst)):
   lst.pop()
print(lst)
同上，可以删空列表

lst = [11,22,33,44]
lst1 = lst[:]
for i in lst1:
    lst.remove(i)
print(lst)
拷贝lst的元素，通过循环lst1的长度，删空lst

使用for循环清空列表元素内容
    1.从后向前删除 2.创建一个新的容器,循环新的容器删除旧的容器内容
面试题
    lst = [1,[2]]
    lst[1] = lst
    print(lst)
    答案: [1, [...]]  循环
字典和集合
    字典和集合在遍历(循环)时不能修改原来的大小(字典的长度),可以进行修改值
    ![](https://img2018.cnblogs.com/blog/1754444/201908/1754444-20190810165752876-933593647.png)

17.二次编码
编码
ascii码:支持英文,数字,符号，不支持中文，英文一个字节
GBK(国标):支持中文，英文，数字，符号，英文一个字节，中文2个字节
Unicode(万国码):支持中文，英文，数字，符号，都是4个字节
utf-8:支持中文，英文，数字，符号，英文1个字节，欧洲2个字节，亚洲3个字节
字节用于存储和传输
a.encode("gbk/utf-8") -- 编码
a.decode("gbk/utf-8") -- 解码
必会：
python3：默认编码unicode
python2：默认编码ascii
python2不支持中文
重要
encode() # 编码
decode() # 解码
用什么编码就要用什么解码
网络传输一定是字节

原文地址：https://www.cnblogs.com/sunyongchao/p/11332776.html