python_note
Python Dairy
written by Ych
python中’=‘使用大部分即为贴标签用同一个地址!!!!!
- 利用#进行注释
- 通过间隔进行函数容阔【非括号】
- 语句末尾没有分号
- 变量无需声明直接使用
- 变量名不能以数字开头
- 没有变量只有名字，变量必须伴随具体的赋值出现
- 通过反斜杠‘\’进行引号等其他符号的转义输出
- 若想输出文本则利用三引号进行圈阔
- 若字符串中需要的反斜杠太多，则可以利用原始字符串：
Ex: str = r’hello\ wo\r\ld’
Str == hello\\wo\\r\\ld
使用原始字符串时语句末尾不可出现反斜杠
- 强制类型转换时转换数据在括号中：
Ex: a = intput()
a = int(a)
- tab键自动缩进（可进行框选整体缩进）
- && == and
- || == or
- 导入模块（导入库）:
Ex: import random【关键词：import】
- 允许出现连等和连续比较赋值：a = b = c = 5 , 3 < 4 < 5;
- // 作商取整数部分
- ** 作幂运算；
input函数使用：
通过变量接受Input的返回值,【返回对象为字符串类型，若需其他类型可进行强制类型转换】
Ex:
- a = input()直接接收；
- a = input(“2222:”)在字符串内接收变量，所键入内容在分号之后
type函数使用：
Func:获取变量的类型，可用字符串进行接收
isinstance函数使用:
判断该变量是否是目的变量的类型:
Ex: a = “hello”
Bool_val = isinstance(a,str)-->bool_val == 1;
Bool_val = isinstance(a,int)-->bool_val == 0;
if分支语句:
else if == elif
assert断言【抛出异常】:
当assert后面的条件为假时自动抛出异常使程序崩溃:
Ex: assert 3 > 4 -->程序终止
assert 4 > 3-->无任何情况发生；
print函数:
▲print("The length of %s is %d" % (s,x)):
格式化输出数值方法：
占位符与C/CPP相同，添加‘%’转换符，在‘（）’中将所需变量进行填充.
高级用法：
Print(“nnnnnn:” , x):
通过冒号’:’分割输出内容.
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
参数
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
▲sep -- 用来间隔多个对象，默认值是一个空格。【当输出为多个部分时使用 ex:print(str1,str2,str3)】
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。【可以设置end = ‘ ‘来自动分隔输出语句】
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新.
Ex:
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("www","runoob","com",sep=".")
# 设置间隔符
www.runoob.com
Range函数：
range(start, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
for循环：
在Python中可以利用for循环遍历任何变量数据；
Ex:
For i in “hello”:
Print(i)
此循环可以遍历hello中的每一个字符；
for i in range(5):
Print(i)
循环可以遍历[0,5)的每一个整形数据
Con:
例如因此即使在循环for中i == 3此时在内部使i=6下次循环时i依然为从3的下一个数4开始。
List列表:【具有下标操作符[]】
列表元素可以存放不同的元素及任何的对象；
列表的方法:
列表的初始化: list_1 = []
1.Append() --->向列表尾部中添加有且只能有一个元素;
2.Extend() --->向列表中添加多个元素，且元素需用列表形式存放:
Ex:
s = []
s.extend([1,2,3])
3.insert(pos, obj)---->向列表中指定位置插入一个元素，第一个参数为插入的位置，第二个参数为插入的对象;
- len(<list>):获取列表的长度:len([1,2,3]) = 3;
- remove(obj) --->从列表中删除指定的元素【参数为所要删除的元素名】;
- del <list>[pos] --->删除列表的指定位置或整个列表:
Ex:
① l = [1,2]
Del l[0]
l = [2]
② l = [1,2]
Del l
l = [NULL]
- pop (pos) --->取出（删除）列表尾部元素并返回该元素
- 列表切片：
<list> [start:end]:此为左闭右开区间，如果左侧为空参数则为从初始位置，如果右侧为空参则为列表末尾位置;
列表切片结果也为列表，可以用变量进行接收切片的列表
- 列表类型完成了对“+”的重载，若加号两侧均为列表类型，则会完成
- 列表类型完成了对“*”的重载，若<list>*n则表明当前列表内的元素复制n次并返回列表对象；
- 成员关系操作符:
①in : 判断元素是否包含在改列表内
L = [1,2,3]
1 in l == TRUE;
5 in l == False
②not in：与in的真值相反。
- dir展示某类的BIF函数:
Dir(list):展示list的BIF函数
- count(obj) --->显示列表内的参数（obj）在列表内重复的次数
- index(obj，pos_st,pos_ed) --->返回元素在列表内在（pos_st,pos_ed）范围内的索引，返回索引到的第一个位置的元素.
- reverse --->进行列表的反转，返回一个反转后的列表给自身.
- sort() --->对列表进行排序【默认从小到大进行排序】
若想从大到小进行排序:
则sort()中赋予参数reverse = True[默认reverse = false]
ATTENTION:
对于list1 = list[:]和list2 = list;
在不改变任何属性的情况下，都会完成对list的元素拷贝
但是list1 = list[:]此方法实则为创建了一个新的List变量，而
list2 = list 此时list2只是对list的一个标签，若改变list内容此时list2的内容也会发生改变同理，若对list2内容进行更改，则list中的内容也会发生相同的变化【类比地址，即list = list2实则为两变量指向了同一个地址】
Con:
- 若创建新的与原列表相同的列表 list_new = list[:]
- 若创建新的指向原列表的列表变量 list_new = list
tuple元组【无法被修改的列表】:
若想修改元组中的内容可以利用强制类型转换；
获取列表中元组对象的的值：
val1 ,val2 = [(‘1’ , ‘2’)] -->此时val1和val2分别对应列表中元组的两个值
元组的创建tuple_new = ()【利用小括号进行创建】
支持下标访问和切片操作
元组无法被修改
创建含一个变量的元组 tuple_new = (1,):必须含有逗号因为（5） = 5
支持“+”连接和“*”重复操作
string字符串
方法：
Capitalize 字符串第一个字符大写返回新的字符串.
Casefold 字符串中大写变为小写返回新的字符串.
Center(width) 字符串居中并用空格填充width长度.
Count(sub,[st],[ed]) 查找子串sub在字符串[st,ed](默认完整字符串)中出现的次数.
Endwith(sub,[st],[ed]) 判断字符串的结束与字串的关系，若相同则返回true.
Expandtabs([tabsize]) 将\t转换为空格，默认8个空格.
Find(sub,[st],[ed]) 查找子串，若找到则返回下标，若找不到则返回-1.
Index(sub,[st],[ed]) 查找子串，若找不到则会抛出异常.
Isalnum 若字符串中都是字符，且字符均为字母或数字则返回true
Isalpha 若字符串中所有字符都为字母则返回true.
Isnumeric 若字符串中所有字符均为数字则返回true.
Islower 若字符串至少含有一个字母，且所有字母均为小写则返回true
Isupper 若字符串至少含有一个字母，且所有字母均为大写则返回true
Isdigit 若字符串只包含数字则返回true.
Isspace 若字符串只包含空格则返回true
Istitle 如果字符串开头为大写字母，其余均为小写字母则返回true.
Join(sub) 将字符串作为分隔符插入到sub中.
Ljust(width) 左对齐，空格填充width的长度.
Rjust(width) 左对齐，空格填充width的长度.
Lstrip 去掉字符串开头的所有空格
Rstrip 去掉字符串结尾的所有空格.
Partition(sub) 将字符串分割成三个元素的元组，元组元素为（pre_sub,sub,for_sub）.
Rpartition(sub) 与partation功能类似，查找顺序为从右侧开始查找.
Replace(old_str,new_str[,count]) 将old字符串替换为新的字符串，且替换次数不超过count(默认为1)
Split(sep = null,maxsplit = -1)默认无参为以空格为分割进行切片maxsplie若有参数则其为其最大分割数.
Splitline 以\n为分割进行切片操作
Strip(<char>) 删除字符串前面和后面的所有char字符（默认为空格）.
Startswith(sub,[st],[ed]) 判断字符串的开头是否是以sub开始若是则返回true.
Swapcase 反转字符串中的大小写.
Title 将字符串进行标题化,以大写开头其余字母均为小写.
Translate(table) 根据table的规则将字符串中的字符进行相应的转换,table的规则用maketrans(old_ch,new_ch)来制定.
Zfill(width) 返回长度为width的字符串，源字符串右对齐，前面用0进行填充.
字符串的格式化:
数字的占位符的格式化输出:
“{0}...{1}...{2}.format(“a” , “b” , “c”).原字符串格式化输出为a...b...c
字符占位符的格式化输出：
“{x}...{y}...{z}.format(x = “a” ,y = “b” ,z = “c”).
Ps:
1.当使用字符占位的格式化输出时,在format中必须声明每个占位符的代表字符串即 x = “a”
2.当混合使用数字和字符时，数字占位符需要在字符占位符之前使用.
序列方法:
- len(<>)获取序列长度.
- Min(<>) 返回该序列的最小长度.
- Max(<>) 返回该序列的最大元素.
Ps:
①当序列为字符串时，自动剪切字符串为单个字符.
②使用max,min函数时必须保证序列中的类型均相同，若出现不同类型的元素，则无法使用该函数.
- Sum(iterate[,st]) 将序列中的元素相加【序列中的元素均为数值型元素】
- Sorted() == list.sort() 对序列进行排序.【默认从小到大进行排序.】
- Reversed() 将序列进行翻转,返回迭代器，需用容器进行承接
Ex:
List_1 = [1,2,3,45,7].
List_2 = list(reversed(list_1)).--->list_2 = [7,45,3,2,1].
- enumerate() 将序列中的元素的下标与元素存入同一个元组,并返回一个迭代器,需要容器进行承接
Ex:
L = [1,2,3,4]
List_1 = list(enumerate(l))
List1 = [(0,1),(1,2),(2,3),(3,4)].
- zip(a,b) 将a,b相同位置的元素进行打包,取两个序列最短的序列为最终长度,超出该长度的元素略去,将a,b相同元素进行配对.
Ex:
A = [1,2,3]
B = [4,5,6]
C = list(zip(A,B)).
C == [(1,4),(2,5),(3,6)].
函数:
函数的构建:
Def func_name():
通过缩进来表明是否是该函数中的内容.
函数可以返回列表和元组类型.
全局变量关键词:global.:
在外部直接声明变量，只是在使用时提前golbal 进行解释：
Ex:
Sum = 0
Def fx():
Global sum
Sum+=1
函数内部无法修改全局变量.
函数调用时形参可以为元组类型或列表类型，在函数定义时声明方式田间‘*’关键字符
Ex:
Def fun( *params ):
函数嵌套:
在一个函数中可以嵌套定义另一个函数，当调用基函数时可以完成嵌套函数的构造,但无法直接调用被嵌套的函数.
函数闭包:
当内嵌函数用到基函数的参数且基函数的返回值与内嵌函数有关时，即为函数闭包.
Ex:
Def funx(x):
Def funy(y):
Return x * y
Return funy
Funx(A)(B) 【为funx和funy赋初值的方法通过小括号进行间隔.】
Ps:
当发生函数闭包时,当基函数元素在子函数中调用时
①添加关键词：
在子函数中Nonlocal . 此时系统不会将改变量认为时局部变量.
Ex:
Def funx():
X = 5
Def funy():
Nonlocal x
X *= x
Return x
Return funy()
即为在子函数中声明了一个和原变量相同的变量，在基函数中的函数值不会发生改变.
②将基函数的变量存储到容器中:
容器的元素存储方式和普通变量不同,当存到容器中时，即为存到堆存储区,在程序任意子位置均可进行调用.
Lambda表达式:
关键词 : lambda
【声明】Func = lambda x : x * 2
【调用】func(5) ---> 10;
BIF:
Adt:
①不用命名函数，直接调用
②空间自动释放，不会占用过多内存
③不需写出函数调用.
Filter(func,<list>)
Func：筛选功能.
即按照func的功能进行筛选出符合条件的元素，返回类型为列表类型.
Map(func,<list>)
Func: 对列表内的每一个元素完成func的功能.
按照func的功能对列表内的每一个元素进行变化,返回类型为列表对象，需要强制类型转换.
Ps:两函数的func位置均可以使用lambda表达式.
字典类型：
Attention:
字符串，元组，列表 皆为序列类型
字典为映射类型.
键值组合成字典类型：
每一个键对应一个索引值，使用时通过相应的键来索引.
关键标识符：大括号‘{}’和冒号‘:’ || dict(map)
Ex:
Dire = {‘xxx’:’yyy’ , ’aaa’:’bbb’}:xxx即为yyy的索引值，’aaa’即为’bbb’的索引值，使用时利用dire[‘xxx’] ==’yyy’类似数组直接使用
Dict_2 = dict(‘xxx’ = ‘yyy’, ‘aaa’ = ‘bbb’)也可以创建字典类型.
▲进行强制类型转换时注意dict(map)：dict()括号中有且只能有一个参数.
Ex:
Dict_1 = dict(((1:1),(2:2))) 即将多个元组类型强转为字典类型
可以直接通过下标运算符来改变索引值的内容.也可以直接通过下标操作扩充字典内容.
Ex:
Dict_3 = {}
Dict_3[‘hello’] = ‘world’
Dict_3 = {‘hello’:’world’} //完成了字典的扩充.
Dict_3[‘hello’] = ‘new’
Dict_3 = {‘hello’:’new’} //完成了字典的更新.
方法：
- fromkeys(*keys[,val]):
*keys 用元组形式进行声明,val为所有keys的值，即所有keys值均对应一个val值，若不加val值默认为null
- keys()
返回字典的所有键值
- values():
返回字典的所有value值
- items():
返回字典的所有项，每一项均为键值和相应的索引值，每一项通过元组的形式进行返回.
- get(<key>[,str]):
若访问到不存在的key值返回一个none而不是报错.
若str赋予参数则当访问到不存在的key时输出str语句，若key存在则正常输出keys的索引值.
- 可以搭配 ’in’ 关键词进行使用,判断字典中是否存在key值或val值.
- clear():
清空字典.
- copy():
浅拷贝，与’=‘不同重新构造一个字典类型，拥有新的地址.
- pop(<key>):
弹出key对应的值
- popitem(<key>):
弹出对应的项，以元组的形式进行弹出.
- setdefault(<key>):
访问key的val值，当不存在key值时创建一个val为null的key值不会报错.
- update(<for_dict>):
用for_dict更新该字典
Ex:
A = {1:null,2:’two’}
B = {1:’one’}
- update(b)
A = {1:’one’ , 2:’two’}
集合类型:
关键词 : set
特点：
①随机性：不可以用下标进行索引
②互异性：没有重复的元素.
Tips:
可以通过’in’和’not in’来判断某元素是否在某一容器中【包括集合类型】
方法：
1.Add():
向集合中添加元素
2.remove():
移除集合中的元素.
不可变集合：
Frozenset():创建不可变集合，集合固定不可对该类型集合进行增删改等操作.
文件操作：
读取文件路径需要双斜杠或单反斜杠.
▲只有当文件正常打开和正常关闭时才会被保存否则缺失任意环节均不会被保存
部分方法:
- open(<路径> ，<打开方式>):
路径中间断均为双斜杠或单反斜杠.
通过打开方式来判断是否为只读或可更改文档.
|
打开模式 |
执行操作 |
|
r |
以只读方式打开 |
|
w |
以写入的方式打开,会覆盖已存在的文件（若没有该文件则会进行新建文件） |
|
x |
如果文件已经存在用此模式打开会引发异常. |
|
a |
以写入的方式打开,若文件已存在则会在文件末尾进行追加写入. |
|
b |
以二进制模式打开文件. |
|
t |
以文本模式打开文件. |
|
+ |
可读写模式（可以添加到其他模式中使用） |
|
U |
通用换行符支持 |
- read(len):
读取文件且指向所读取位置,len为所读取的字符数.
- close():
关闭文件.
- tell():
返回当前指向的字节位置.
- seek(offset , from):
改变文件指针,from有三中参数:
- -->从文件开头
- -->从当前位置
- -->从文件末尾
offset为偏移大小
- readline():
打印文件指向开始的当前行
Ps:可以利用for循环直接将文档的的每一行进行输出：
Ex:
For each_line in f:
Print(each_line)
- writelines(seq):
向文件中写入字符串序列,seq为返回一个可迭代的字符串对象.
OS模块【跨平台使用】:
OS.path模块【跨平台使用】:
Pickle模块:
主要方法；
Pickle.dump(<内容> , <文件>):
即将内容以二进制的形式输入文件中
Pickle.load(<文件>):
将二进制文件打开
异常处理：
Try:
尝试代码
Except <错误类型> 【错误类型可以为元组类型，当错误为元组任意错误时执行错误处理】:
处理代码
Finally:
无论如何都会执行的代码
Ex:
Try :
XXX
Except oserror as reason【将错误名称存储为字符串(需要强制类型转换)】:
Print(“xxx” + str(reason))
Finally_ex:
Try:
F = open(‘’)
Xxxx[出现异常]
- close() 【此处不会被执行】
Except XXX:
错误处理
Finally:
F.close() 【执行此处的close】
else语句扩充内容：
- 配合if语句
- 配合while语句：
若在循环过程中不存在break则在循环正常结束时会执行else语句
- 配合异常处理try语句：
若抛出异常执行except语句，若正常结果执行else语句
with语句：
针对直接访问文件出现问题：
- 出现异常
- 忘记关闭句柄
利用with语句：
With open(‘<路径>’) as my_file：
可解决该问题无需在使用try + finally语句
模块【ex:easygui】导入:
①Import easygui使用时需用easygui最为对象
②from easygui import *:导入Easygui使用时直接使用内置方法即可无需添加对象
③import easygui as eee<自定义对象>
Ex:
①import easygui
Easygui.msgbox(‘aaaa’)
②from easygui import *
Msgbox(‘aaaa’)
③import easygui as yyy
Yyy.msgbox(‘aaaa’)
①②③达到相同效果
面向对象:
构造类后，若要创建该类的对象：
A = turtle()【turtle为自定义的类，小括号需存在】
python中类的函数中的self相当于C++中的this指针，任何函数均需含有self变量，在函数内部改变自身属性时也需要使用self
Ex:
Class a:
Speed = 5
Def speedchange(self,n):
Self.speed = n【需添加self】
▲python中的构造函数即初始函数为 ‘__init__()【此处为双下划线】’，当为默认构造时自动调用，当重写构造时，手动调用
公有和私有机制：
python中正常的属性和方法均为公有成员
若想将其私有化，在构造该成员时，该方法/属性的名字前添加双下划线即可：
Ex:
Class person:
Name = ‘aaa’ 【此属性为公有】
__name = ‘bbb’ 【此属性为私有】（通过设置接口函数访问该变量）
Ps:若想直接访问私有成员可以通过访问‘_<类名>__<成员名>’
以上个例子为例，若想直接访问__name:
- _person__name
这样即可访问该变量.
▲当自定义类中不含有任何成员时,添加关键词 ’pass’ 即可完成
Ex:
Class A:
Pass
继承机制：
可以重写python原有类：
class int(int):
def __add__(self,n):
return int.__sub__(self,n)
a = int('3')
b = int('1')
print(a + b)
>> 2
在定义类时添加小括号，在小括号中填写继承自的类：
Ex:
Class A:
Pass
Class B:
Pass
Class C(A,B):
Pass
此时C就继承了A和B
类的组合：
Class A:
Pass
Class B:
Pass
Class C:
Def _init_(self):
Self.a = A()
Self.b = B()
这样即完成了C类对AB类的组合
类的分级：
类定义【类的定义】
类对象【static类型】
实力对象【由类派生出的对象】
Ex:
class A:
num = 0
def _init_(self,n):
self.num = n
a = A()
print(a.num)
b = A()
A.num = 5
print(b.num)
若要改变static性质的属性：
只需在改变变量时使用type：
Ex:
Class A:
Num = 1
Def f(self,n):
Type(self).num = n
▲即可改变A类型的Num属性，即之后产生A的实例对象均为新的num属性
ATTENTION：
若在类中的方法，在主函数中调用时，调用成属性，则会在原类型中新建一个改名字的属性并覆盖原方法
Del既可以删除对象，又可以删除属性
BIF方法：
①issubclass(<class A>,<class B>):
判断A类和B类是否存在继承关系，若存在则返回TRUE
Ps:所有类都默认继承自’object’类
②isinstance(<object a>, <classinfo b>):
判断对象a是否来自类（或类的元组之一）b，若来自b则返回true
Ps:若第一个参数不是对象，则永远返回flase，若第二个参数不是类或含类的元组，则返回typeerror.
③hasattr(<object a> , <name(str)> ):
判断a对象是否含有name的属性，name参数传入时必须是字符串形式.
④getattr(<object a> , <name(str)> [,<default>]):
若a对象含有属性name则返回name属性，若不存在，则执行default语句
⑤setattr(<object a> , <name(str)> ,<value>):
若a对象含有name属性，则将该属性的值设置为value，若该对象不存在该属性，则会新建该属性并赋值value.
⑥property(<getvalue>,<setvalue>,<delvalue>):
getvalue为设置属性的方法
setvalue为改变属性的方法
delvalue为删除属性的方法
利用propety的BIF方法可以在外部直接对某一属性进行增删改查的操作：
Ex:
class A:
def add_x(self):
self.size = 5
return self.size
def set_x(self,n):
self.size = n
def del_x(self):
del self.size
x = property(add_x,set_x,del_x)
a = A()
a.x = 7
print(a.x)
del a.x
Ps:所要设置的属性名不能和函数中的参数相同
魔法方法：
- 构造器析构器：
①构造器
‘__init__()’和’__new__(cls,XXX)’:
一般情况下在调用__init__之前默认调用__new__方法
Ex:
class CapStr(str):
def __new__(cls,string):
string = string.upper()
print(1)
return str.__new__(cls,string)
def __init__(self,string):
self.str = string
print(2)
a = CapStr('hello')
>>1
>>2
通过这种方式发现在调用构造器时首先调用__new__,再调用__init__
②析构器：
__Del__(self):
垃圾回收机制，在变量的存在周期结束时自动调用，无需手动调用
- 算数运算：
①加减法运算：
‘__add__’和’__sub__’方法：
__add__定义加法运算
__sub__定义减法运算
class int_test(int):
def __add__(self,other):
return int.__add__(self,other)
def __sub__(self,other):
return self - other
a = int_test('5')
b = int_test('6')
print(a + b)
print(a - b)
在该样例中__add__的加法方法可以正常实现，而__sub__的减法方法无法正常实现，这是由于在__add__中调用的为其基类的加法完成__add__方法,而在__sub__中调用的为’-’号方法，而’-’号又会再次调用__sub__方法，这样就产生了死循环从而无法完成正常的减法.
解决方法：
def __sub__(self,other):
return int(self) - int(other)
改成强制转换int类型即可完成，因为在int类型中没有重载__sub__所以可以正常完成减法
②反运算符：
‘__radd__’’__rsub__’:
对于a + b当a中没有加法操作函数即__add__函数时，程序再找b是否含有反运算函数,若b含有反运算符则执行b的反运算函数：
Ex:
class try_test(int):
def __radd__(self,n):
return int.__sub__(self,n)
a = try_test('5')
print(3 + a)
>>2
因为‘3’为一个整形数值，没有‘__add__’操作函数所以执行a的反运算函数’__radd__’，且在执行__radd__函数时传递的第一个参数依然是自身数值，第二个参数时 3
描述符：
PASS
定制序列：
class CountList:
def __init__(self,*args):
self.values = [x for x in args] //注意此条语句使用方法
self.count = [0 for x in args]
self.vk = dict((zip(self.values,self.count)))
def __len__(self):
return len(self.vk.keys())
def __getitem__(self,key):
self.vk[self.values[key]] += 1
return self.values[key]
c1 = CountList(1,5,3,4)
print(c1[3])
print(c1.vk)
迭代器：
对于字典类型：
Dict_1 = {}
For each in dict_1:
Print (each) 【此处each为每一个字典的键key值而不是value值】
生成器推导式：
①列表推导式
②字典推导式
③集合推导式
List_1 = [x for x in ‘hello’] ---->将hello的所有字母分离成列表元素
Dict_1 = {i:i %2 == 0 for i in range(10)} --->十以内偶数的判断
Set_1 = {i for i in [1,2,3,4,55,55,6,6,7]} --->将列表元素无序去重化
迭代器：iter / next
string = 'hellkskda'
it = iter(string)
while 1:
try:
print(next(it))
except StopIteration:
break
用next来改变迭代器iter指向的位置
模块【正式】：
导入模块后注意模块的命名空间
模块作用：实现代码的重用
Ex:
Import turtle as t
- turtle --->高亮即为命名空间
模块<--->主函数机制：
If __name__ == ‘__main__’:
当某程序作为模块导入时，需要此机制
def gx():
print('test..gx')
def fx():
print('test..')
if __name__ == '__main__':
gx() //当作为主函数是自动实现，而作为模块是不自动实现
在if __name__ == ‘__main__’机制下只添加函数名，不是函数的实现方法
模块搜索路径：
模块的放置位置，即python搜索模块的路径，查询方式：
import sys
print(sys.path)
将模块放入该显示结果的路径下即可，一般放入’package’下
Ps:当搜索路径中不存在该模块时，可以手动添加路径：
import sys
sys.path.append('')
在append()方法中添加路径即可
包的创建：
目的：更好的管理模块，将模块的位置清晰化
方法：
①在sys.path【模块路径】下创建文件夹
②创建名为’__init__.py’的文件文件可以为空但必须创建
③将模块放入该文件夹下
导入方式：
Import <文件夹名.模块名>
Ex:
import pack_1.test_m as t #已经创建了名为pack_1的文件夹且含'__init__'文件和该模块
t.fx()
在自定义模块中，将外部接口类写在’__all__’中
爬虫：
URL的一般格式：
Protocol://hostname[:port]/path/[;parameters][?query]#fragment
‘[]’为可选项
URL由三部分组成：
第一部分是协议：
http https ftp file ed2k
第二部分是存放资源的服务器的域名或IP地址（有时候要包含端口号，各种传输协议都有默认的端口号，如http的默认端口号为80）
第三部分是资源的具体地址，如目录或文件名
获取网站：
import urllib.request
response = urllib.request.urlipen(“<url地址>”)
html = response.read
html = html.decode(“utf-8”) //解码格式
TEST_1:
加载一只猫：
所获取的url地址需为图片的具体地址
import urllib.request
response = urllib.request.urlopen("http://placekitten.com/g/500/600")
jpg = response.read()
f = open('test.jpg' , 'wb')
f.write(jpg)
f.close()
通过二进制方式打开文件将文件写入,通过urlopen().read()方式打开获取的为二进制文件
GUI之tkinter:
导入tkinter模块：import tkinter as tk
tk.Tk() --->设置窗口对象
tk.Label() --->设置窗口文字，图片
配套使用tk.pack()
各种GUI模块都需要在pack()之后才能显示
循环机制的建立：tk.mainloop()
ex:
import tkinter as tk
app = tk.Tk()
app.title("hello")
thelabel = tk.Label(app,text = "1151515")
thelabel.pack()
app.mainloop()
tk.Button() --->设置按钮
tk.Frame()--->设置框架
ex:
import tkinter as tk
class APP:
def __init__(self,master):
frame = tk.Frame(master)
frame.pack()
self.say_hi = tk.Button(frame,text = 'hello',bg = 'black',fg = 'white',command = self.do_hi())
self.say_hi.pack()
def do_hi(self):
print('1111')
root = tk.Tk()
app = APP(root)
root.mainloop()
通过tk.Label()加载图片：
①通过tk.PhotoImage(file = ‘<path>’)载入图片
②通过tk.Label(<Tk实例对象> , image = <导入的图片变量>)
ps:在Label中通过改变justify设置左右对齐方式,通过padx/pady设置与边界的间距。若在一个Label中则可设置将文字嵌套在图片中，设置compound参数调整图文嵌套类型,font(<字体格式>,<字体大小>)设置字体样式
ex:
from tkinter import *
root = Tk()
textLabel = Label(root,text = '啊这')
textLabel.pack(side = LEFT)
img = PhotoImage(file = "timg.gif")
imgLabel = Label(root,image = img)
imgLabel.pack(side = RIGHT)
root.mainloop()
通过var描述显示的字体文本，通过var.set改变文本内容
var需为StringVar类对象,此时在label中不能再用text参数而是用textvariable参数后面添加var变量
ex:
from tkinter import *
def callback():
global sum
sum += 1
if sum == 1:
var.set('world!')
if sum == 2:
var.set('yes')
sum = 0
root = Tk()
frame1 = Frame(root)
frame2 = Frame(root)
var = StringVar()
var.set('hello')
textLabel = Label(frame1,
textvariable = var,
padx = 10
)
textLabel.pack()
gif = PhotoImage(file = 'timg.gif')
gifLabel = Label(frame1,image = gif)
gifLabel.pack()
nextButton = Button(frame2,text = 'en' , command = callback )
nextButton.pack()
frame1.pack()
frame2.pack()
root.mainloop()
ps：每设置一个窗口需要添加一个框架变量，而Tk类的对象使用一个即可
单选框和多选框：
InVar为选中格式
Checkbutton为选框内容
from tkinter import *
root = Tk()
v = IntVar()
c = Checkbutton(root , text = 'llll' , variable = v)
c.pack()
mainloop()
通过pack(anchor = )中anchor参数控制单选框的对其位置，其参数分别为’n’’s’’w’’e’
from tkinter import *
root = Tk()
v = []
girls = ['hhh' , 'lll' , 'eee']
for i in girls:
v.append(IntVar())
c = Checkbutton(root , text = i, variable = v[-1])
c.pack(anchor = 'w')
mainloop()
实现单选的方法：
对Radiobutton选中的框进行（value）赋值，且赋所赋值必须不同，才能实现单点，如果赋值相同则会导致相同的value框均被选中
