总结

周总结

本周学习了很多知识点现在回顾一下，重新复习一下学的知识。

基础数据类型 布尔值，元组，集合。

1. 布尔值 bool
布尔值时用来判断事务的对错，是不是可行的。只要用于流程控制中。
它只有两种形态： 可行 True ， 不可行 False
2. 元组tuple
元组也称为不可变列表，元组内索引绑定的内存地址不能被修改。 # 值改变内容地址肯定变
内部可以存放多个数据，数据值和数据值之间用逗号隔开。数据值可以是任何类型
'''元组内如果只有一个数据值 也要加上逗号'''
3.集合set
主要功能是去重和关系运算
大括号括起来内部存放多个数据值。不是以k，v值存放。如果括号内没有数据值默认是字典。

与用户交互

1. input 获取用户输入
语法：
变量名 = input('文本')
2. 输出内部信息
print() 括号内可以放数据值也可以放变量名，支持多个。逗号隔开即可
"""print在python2中可以不写print直接写变量名
  raw_input 另一种方法 """

格式化输出

需要提前设置好模板  使用%s占位符
eg  a = ```你好 %s 先生，```
print(a %('需要占位的信息'))
多个占位符 在 后面加上逗号依次输入信息即可

数学运算符

 加(+)、减(-)、乘(*)、除(/)、整除(//)、取余(%)、幂赋值运算(**)

比较运算符

< > <= >= ==(等于) !=(不等于)

常用的赋值符

链式赋值

可以使用链式赋值快速的给多个变量名修改数据值
a = 60
b = a
c = b
a = b = c = 6 #  简化写法
print(a, b, c, ) # 6 6 6

交叉赋值

可以快速让不同的变量名互相转换绑定的变量值
a = 40
b = 30
temp = a
a = b
b = temp
print(a, b, ) # 30 40

解压赋值

解压辅助是把数据类型中的数据 依次绑定给依次输入的变量名，也可以打破个数限制。 #
a = ['b', 's', 'd', 'f', ]
q, *w = a
print(q) # b
print(w) # ['s', 'd', 'f']

逻辑运算符

and 与
连接的多个条件全部成立 结果才成立
如果从里面条件有一个不成立那么结果就不成立
如果and左边的条件是成立的 那么久完全取决于右边的条件 右边的如果直接是数据值那么结果就是该数据值，如果是表达式 则位布尔值
or 或
连接的多个条件只要有一个成立那么结果就成立
发现一个成立 
not 非 将条件翻转

成员运算符

判断课题在不在一个群体里面
 数据值   in  变量名
 变量名   in   变量名2 # 可以判断该变量名的数据值在不在  变量名2 里

身份运算符

id() 返回数字该数字是内存地址
is 判断内存地址是否相同
== 判断数据值是否相同

流程控制和垃圾回收机制

垃圾回收机制

引用计数

数据值身上的引用计数没多绑定一次 引用计数就+1
每删除一个绑定的变量名 引用计数就 - 1

标记清除

主要用在循环引用问题
append. 在尾部添加数据值
a1 = [6, 2]  # 引用计数为1
a2 = [7, 8]  # 引用计数为1
a1.append(a2)  # a1 = [6, 2, [7, 8]]引用计数为2
a2.append(a1)  # a2 = [7, 8, [6, 2]]引用计数为2
del a1  # 断开变量名a1 与列表的绑定关系后引用计数为1
del a2  # 断开变量名a2 与列表的绑定关系后引用计数为1

分代回收

主要根据数据值使用的次数，改变监测的频率，数据值使用次数越高，监测频率越低。（频率高少监测）

流程控制理论

顺序结构

顾名思义
按照从下往下的顺序执行

分支结构

根据 条件的不同做出不同的流程

循环结构

根据某个条件出现重复

流程控制中 如果多行子代码都同属与一个父代码那么子代码应保证相同的缩进值

Tab 快捷键

分支结构

1 . 单if
语法结构
  if 条件:
  条件成立之后执行的子代码(可以有多行)
2. if else
"""语法结构
   if 条件:
    条件成立后执行的子代码
   else:
    条件不成立后执行的子代码"""
3. if elif else
"""语法结构
   if 条件1:
   条件1成立之后执行的子代码
   elif 条件2:
   条件1不成立，条件2成立之后执行的子代码
   else:
   条件都不成立的情况下执行的子代码
elif可以写多个，子代码达成条件永远只会走一个"""

if 嵌套

在if条件中还可以通过缩进的方法在子代码中使用if等分支
# 如果女孩子的年龄大于30说 哇我就喜欢你这年龄的加微信 否则那挺年轻啊
# 如果成功了 则去吃饭 看电影 开车回家车坏了.  否则 那算了吧
is_success = True
age = int(input('美女你今年多大啦'))
if age > 30:
    print('哇我就喜欢你这年龄的,加微信')
    if is_success:
        print('吃饭 看电影 开车回家车坏了')
    else:
        print('那算了')
else:
    print('那挺年轻啊')

循环结构

while循环

让一些代码反复的执行
'''语法结构
while 条件:
    条件成立后执行的循环体代码
判断条件是否成立，如果成立的话执行循环体代码，.循环体代码执行完毕后 再次判断条件是否成立 如果成立则继续执行循环体代码 如果不成立则跳出循环'''

"""1.while死循环
死循环会极度影响电脑的性能，会使CPU功耗极剧上升。甚至会损坏硬件。
2.while嵌套
在while中可以再循环体子代码中再添加一个while循环体代码。
有几个while循环的嵌套 想结束循环就应该在循环体代码中写几个break(强制结束循环)"""
全局标志位
'''如果不反复的写break可以使用全局标志位'''
我们可以设定一个变量名绑定一个成立的数据值(True)，那么在while条件中添加此变量名 那么就可以一直循环下去。当我们想要结束循环的时候在循环体子代码中把我们设定的变量名修改成 不成立的(False) 那么就会结束循环。

for循环

for循环能做的事情while 循环都能做到
就是在一些场景下比较方便 使用简单
for循环主要用于循环获取存储的多个数据值，不需要结束条件，获取完数据值自动结束。
"""for循环的语法结构
for 变量名 in 循环对象:
    循环体代码"""
循环对象可以是：字符串、列表、字典、元组、集合
for循环体代码中如果执行到break 也会直接结束循环。遇到continue 也会直接结束循环 开始下一次循环。

range方法

range就是帮我们产生一个内部含多个数据值的列表
range方法在py2和py3中的区别
''' 
在python2中range是直接产生一个列表，数据值很多的情况下会占内存空间
python3中的range是直接产生一个列表，你要的时候就会取值  
python2中的xrange其实就是python3的range
python3中的range不占用内存空间，但是可以存取出多数据
'''
rang(1, 25, 2) 起始位， 结束位， 步长

数据类型与字符串内置方法

数据内置方法理论

每一种数据类型都含有一系列操作方法，内置方法是其中最多的。
在python中数据类型调用内置方法统一句式为:句点符
 变量名或 数据值 或关键字 str.
# 补充：如何查看数据类型的内置方法
 借助于编程软件的自动提示，采用句点符快速查看

整型内置

类型转换
int(其他数据类型)  只能转换纯数字 
十进制转其他进制
bin 二进制   oct 8进制  hex十六进制
0b        0o       0x
print(bin(100))  # 0b开头二进制 bin(用来转二进制)
print(oct(100))  # 0o开头八进制 oct(用来转八进制)
print(hex(100))  # 0x开头十六进制 hex(用来转十六进制)
其他进制转十进制
# 其他进制转十进制  用 int
print(int(0b1100100))
print(int(0o144))
print(int(0x64))
# 其他进制数转十进制 字符串用法，在后面要告诉int是哪种进制
print(int("0b1100100", 2))
print(int("0o144", 8))
print(int("0x64", 16))
"""python 对数字精确度低，python有很多厉害的模块，如果需要进行精确计算那么要用到模块numpy...."""

浮点型内置方法

只能转换数字的数据类型(整型，浮点型，字符串）只能转换字符串里的整数或者只有一个小数点的数字也可以转换，可以识别小数点(但是只能识别1个小数点)
类型转换
float(其他数据类型)

字符串内置

类型转换
res = str(11)
print (res, type(res))
res1 = str(11.11)
print (res1, type(res1))
res2 = str('12')
print (res2, type(res2))
res3 = str([1, 2, 3])
print (res3, type(res3))
res4 = str({'name': 123, })  # 字典只能取键值
print (res4, type(res4))
res5 = str((1, 2, 3, 4))
print (res5, type(res5))
res6 = str({1, 2, 3, 4})
print (res6, type(res6))

索引取值

索引取值:    根据索引位取值
支持负数从尾开始 ，起始从0开始超出范围会报错   

切片操作

切片操作:
在切片操作中 我们需要注意的是 我们输入的索引位是顾头不顾尾， 切片也可以用负数（从左往右），我们也可以修改从右往左[-1:-4:-1] -1代表从右往左。也可以设置隔位切取 输入 2 代表隔1位取一次,如果索引内只输入冒号的情况下默认全取也可以在后面输入隔位切取。 
a1 = 'hello world'  # 字符串里空格也算字符 
print(a1[1:5])  # 顾头不顾尾 从索引1一直切取到索引4
print(a1[-5:-1])  # 注意只能从左往右
可以修改切片方向 （间隔）
print(a1[1:5:2])   # 可以设置 间隔几个取一个值  默认是1
print(a1[-1:-5:-1])  # 上面切片操作只能从左往右 -1代表从从右往左
print(a1[:])  # 不写数字默认全取

统计操作

统计字符串里字符的个数，字符中的空格也算长度和个数
len
a1 = '123456'
print(len(a1))

移除首位字符操作

.strip  
在我们输入用户名的时候有时候会不小心多输了一个空格，那么用strip就能去掉首位的字符。
"""也可以从移除左边的或者右边的，+上L 或R"""

切割操作

在我们是使用split切割操作时 需要指定却要切割的字符，在我们使用split中也可以限制切除几个指定字符（maxsplit）来设置最大切割数，还可以改变方向切割
res = 'tank|123|eee'
print(res.split('|'))  # 该方法处理完成后是一个列表

字符串格式化输出

format
在我们没学习字符串格式化的时候都是使用占位符%s ，比较麻烦。字符串格式化format比较简便。使用大括号{}占位 .多个{}也可以使用数据值中的索引位来占位。

大小写相关

"""当我们在日常输入图片验证码的时候会有大小写之分，使用.upper或 .lower 来将用户输入的验证码统一转换大小写后在和验证码校对"""
.upper   转大写
 .lower  转小写
 isupper()  是否是全大写
islower()  是否是全小写
.isdigit  是否是纯数字

替换

.replace 
替换字符中指定的内容

字符串拼接

.join
字符串与字符串之间可以使用+法，只能和数字*。  加法过程中可以在+中添加符号

统计字符出现的次数

.count

判断字符串的开头和结尾

.starswith
.endswith

列表内置方法

类型转换

类型转换
list(数据类型)
print(list())
能够转换的数据类型有 字符串 字典 元组 集合
print(list('hello'))
print(list({'name':'tank', 'pwd': 123}))
print(list((1, 2, 3, 4)))
print(list({1, 2, 3, 4}))
"""列表索引取值，列表切片操作，列表方向操作，统计列表中数据的个数和字符串一样"""

修改数据值

l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]  # 有一个列表l1
l1[0] = 111  # 修改l1列表中索引位0的值为111
print(l1)

尾部追加数据值

append 可以把括号内的数据值添加到尾部
变量名.append()

任意位置插入数据

.insert 可以通过索引位在任意位置插入数据值
变量名.insert()

合并扩展

.extend 合并扩展列表
变量名.extend（变量名）

删除数据

del 通过索引位删除数据，也可直接删除变量名
del 变量名[0]   del 变量名
.remove 内置删除法， 可根据具体数据值删除
变量名.remove()
.pop 弹出法
可以根据数据值弹出不输默认弹出尾部数据，输入不存在的数据返回None

变量名.pop（）

排序

.sort 排序
变量名.sort() 默认升序
reverse= True 翻转 降序

统计列表中数据的次数

.count

可变与不可变

值改变，内存地址肯定变  不可变类型
值改变，内存地址不变  可变类型

字典内置

类型转换
语法： dict()
一般情况下不用dict转字典，主要是自己动手转字典。基本上不用

必须掌握的操作

按K取值

name_dict = {'name’:'tank', 'age':123 }
print(name_dict['name']) #  tank
不推荐使用

内置方法get

.get
name_dict = {'name’:'tank', 'age':123 }
print(name_dict.get('name'))  # tank
print(name_dict.get['hobby'])  # 返回None
print(name_dict.get('age', '没有哦'))  # 123，键存在的情况下获取对应的数据值
print(name_dict.get('hobby', '真没有'))  #键值不存在返回None 根据第二个参数返回真没有

修改键对值

name_dict{'name': 'tank', 'age': 111 }
name_dict['name'] = 'jack'  
print(name_dict)
"""键存在则修改对应的键值，键不存在则新增键值对"""
name_dict('hobby') = 'rap'

删除数据

可以使用前面学过的， del .pop 来操作
name_dict = {'name':'tank', 'age': 123}
del name_dict['name']  # del删除name_dict表中的name键值
print(name_dict)  # {'age': 123}
---------------------------------------------------------------------------------
.pop方法
name_dict = {'name':'tank', 'age': 123}
res = name_dict.pop('age')  # .pop弹出的数据age绑定一个res变量名
print(name_dict)  # {'name': 'tank'}
print（res） # 123           

字典三剑客

keys
一次性获取字典所有的键，结果支持for循环
name_dict = {'name':'tank', 'age': 123}
print(name_dict.keys())  # dict_keys(['name', 'age']

.values
一次性获取字典所有的值
name_dict = {'name':'tank', 'age': 123}
print(name_dict.values())  # dict_values(['tank', 123])

.items
一次性获取字典的所有键对值,生成的是元组
name_dict = {'name':'tank', 'age': 123}
print(name_dict.items())  #dict_items([('name', 'tank'), ('age', 123)])
 #dict_items([('name', 'tank'), ('age', 123)])
小知识：
name_dict = {'name':'tank', 'age': 123}
for i in name_dict.items():  #  i 在字典中循环取键对值
    print(i)  #('name', 'tank')
            #('age', 123)
高级玩法： #解压赋值
for i,j in name_dict.items():  # 对应的变量名获取解压赋值
    print(i,j)  # name tank     age 123

字典内置补充

.fromkeys
快速生成值相同的字典
print(dict.frmkeys(['name', 'pwd', 'hobby'],123))
# {'name': 123, 'pwd': 123, 'hobby': 123}
res = doct.fromkeys(['name', 'pwd', 'hobby'], [])
# {'name': [], 'pwd': [], 'hobby': []}
[]公用数据是个可变类型，所有的键
'name', 'pwd', 'hobby' 指定的对象都是[],修改一个所有都会改。[]列表是个可变量类型。
不可变类型 修改后可以逐个更改

.setdefault 
name_dict = {'name':'tank', 'age': 123}
name_dict.setdefault('name', 'tanke')  # {'name': 'tank', 'age': 123}
键存在就不做修改，键不存在则新添加一个 键值对
name_dict.setdefault('hobby', 'rap')
print(name_dict)  # {'name': 'tank', 'age': 123, 'hobby': 'rap'}

元组内置操作

tuple()
支持for循环的数据类型都可以转成元组
print(tuple('owen'))  # 字符串
print(tuple([11, 22, 33, 44]))  # 列表
print(tuple({'name': 'owen'}))  # 字典
print(tuple({11, 22, 33, 44}))  # 集合

元组的特性

当元组内只有一个元素的时候，根据type查看都不是元组型
而在但个元素后加上逗号，他们才能显示为元组型
'''所以在存储数据时，如果内部只有一个元素，加个逗号'''

索引，切片，间隔，统计个数，成员运算，统计某个元素出现的次数

1、索引取值
l1 = (1, 2, 3, 4, 56)
print(l1[2])  # 结果为3
---------------------------------------------------------------------------------
2、切片操作
l1 = (1, 2, 3, 4, 56)
print(l1[0:2])  # 结果为(1, 2)
---------------------------------------------------------------------------------
3、间隔
l1 = (1, 2, 3, 4, 56)
print(l1[0:4:2])  # 结果为(1, 3)
---------------------------------------------------------------------------------
4、统计元组内元素的个数(len)
l1 = (1, 2, 3, 4, 56)
print(len(l1))  # 结果为5
---------------------------------------------------------------------------------
5、成员运算(in)
l1 = (1, 2, 3, 4, 56)
print(56 in l1)  # 结果为true
---------------------------------------------------------------------------------
6、统计某个元素出现的次数(count)
l1 = (1, 2, 3, 4, 56)
print(l1.count(2))  # 结果为1
---------------------------------------------------------------------------------
1.统计元组内指定数据的索引值
l1 = (1, 2, 3, 4, 56)
print(l1.index(1))  # 结果为 0

集合内置操作

print(set(11))  # 报错
print(set(11.11))  # 报错
print(set('tank'))  # {'t', 'a', 'n', 'k'}
print(set([11,22,33,44]))  # {33, 11, 44, 22}
print(set({'name':'tank'}))  # {'name'}
print(set((11,22,33)))  # {33, 11, 22}
print(set(True))  # 报错
'''整数、浮点型、布尔值无法转换，集合内元素只能是不可变的类型'''
集合也是无序的没有索引概念

去重

a1 = {1, 2, 2, 2, 2, 2, 5, 4, 4, 4, 6, 6, 6, 6, }
print(a1)  # {1, 2, 4, 5, 6}

关系运算

2、关系运算
  判断两个群体的差异，是否有相同的、不同的
l1 = {'owen', 'kery', 'mark', 'jerry'}  # 小李的好友列表
l2 = {'mark', 'tom', 'jerry', 'jack'}  # 小王的好友列表
 # 1.求两个人的共同好友(&) 
print(l1 & l2)  # {'mark', 'jerry'}
 # 2.求小李的单独好友(-)
print(l1 - l2)  # {'owen', 'kery'}
 # 3.求两个人所有的好友(|)
print(l1 | l2)  # {'mark', 'jerry', 'tom', 'owen', 'jack', 'kery'}
 # 4.求两个人各自的好友(^)
print(l1 ^ l2)  #{'tom', 'owen', 'jack', 'kery'}

字符编码理论

1、编码和解码
  编码 (encode) ：
    将人类能够理解的字符编码成计算机能够直接读懂的字符
  解码 (decode)：
    将计算机能够理解的字符解码成人类能够直接读懂的字符
   编码  encode  
    l1 = '小嘛小二郎 背着书包上学堂'
print(l1.encode('utf8'))
结果 b'\xe5\xb0\x8f\xe5\x98\x9b\xe5\xb0\x8f\xe4\xba\x8c\xe9\x83\x8e \xe8\x83\x8c\xe7\x9d\x80\xe4\xb9\xa6\xe5\x8c\x85\xe4\xb8\x8a\xe5\xad\xa6\xe5\xa0\x82'
"""
字符窜前面如果加了字母'b'表示该数据类型为bytes类型
bytes类型可以看成二进制 """
------------------------------------------------------------------------------------
解码  decode 
l2 = b'\xe5\xb0\x8f\xe5\x98\x9b\xe5\xb0\x8f\xe4\xba\x8c\xe9\x83\x8e\xe8\x83\x8c\xe7\x9d\x80\xe4\xb9\xa6\xe5\x8c\x85\xe5\xb0\x9a\xe5\xad\xa6\xe5\xa0\x82'
print(l2.decode('utf8'))
结果 小嘛小二郎 背着书包上学堂
    """
    基于网络传输数据，数据都必须是二进制格式 
    """
------------------------------------------------------------------------------------
数据当初以什么编码编，就用什么编码解码即可
3、python解释器
  python2解释器默认的编码是ASCII码
    1、文件头：必须写在文件的最上方，告诉解释器使用指定的编码
    coding:utf8
    美化后的写法： _*_ coding:utf8 _*_
     2、字符前缀：在使用python2解释器的环境下定义字符串要在前面加个u
      name = u'你好哇'
  在python3解释器中默认的编码是utf8