小知识点笔记一（原始版）

散装知识点1：Python简介
解释型语言：解释，执行，解释，执行...
编译型语言：编译，连接，执行
解释型语言：解释器
编译型语言：编译器，
解释型语言：解释源码，不同平台使用不同的解释器就行
编译型语言：不同平台编译成不同的机器码
python2.4最普及的版本
Python2.6、2.7是过渡版本
Python3.x是高版本不兼容2.4:
Twisted模块不支持3.0 异步网络框架，单线程情况下比多线程还快

Python是从头到尾一行一行执行，Java是从main函数入口开始执行，

散装知识点2：脚本开头
#!/usr/bin/env python
print("helloworld")
第一行声明解释器。环境变量里找Python，如果有自己装Python3.6则使用3.6否则使用自带的Python2.7
如果写成/usr/bin/python就一定使用的是Python2.7

散装知识点3：变量赋值
变量在Python中可以理解为内存地址
a=1
b=a
a=3 (a,b)为(3,1)
其中1,3可以推广到所有的类型对象
内存地址一样的，指向的类型肯定一样。反之，指向类型一样的，内存地址可能不一样
a=[1,2,3]
b=a
a[1]=55
b=[1,55,3]
改变对象内部的东西，所有该对象的引用指向的也全部改变

散装知识点4：字符编码历史
字符编码，二进制通过字符编码转换成字符
ASCII码，用8位1个字节表示
GB2312,1980年的，七千多个汉字
GBK，1995年的，扩展到2万多个汉字
GB18030,2000年的，到2万7千多，包括各民族汉字
Unicode万国码，标准化组织搞的，不论中文英文都是两个字节，这样英文就多用空间了
UTF-8，可变长的字符编码，存英文是1个字节，汉字是3个字节

散装知识点5：Python版本的编码支持
Python2默认是ASCII编码，如果要支持utf8需要写
# -*- coding:utf-8 -*-
Python3默认就支持UTF-8编码

散装知识点N：bytes类型和String类型互相转换
bytes类型，例如视频文件，

文本文件是字符串但是存的时候可以以二进制的形式存

Python2里文本总是Unicode
Python3不会以任意形式隐式转换字符串
二进制通过编码可以变为字符串，
字符串通过解码可以变为二进制
>>'哈哈'.encode('utf-8')
b'xe5x93x88xe5x93x88'
>>b'xe5x93x88xe5x93x88'.decode('utf-8')
'哈哈'

散装知识点N：编码的相互转换
----回顾-----
ASCII码，用8位1个字节表示
GB2312,1980年的，扩展七千多个汉字
GBK，1995年的，扩展到2万多个汉字
GB18030,2000年的，扩展到2万7千多，包括各民族汉字
Unicode万国码，兼容前面的编码。标准化组织搞的，不论中文英文都是两个字节，这样英文就多用空间了
UTF-8，可变长的字符编码，存英文是1个字节，汉字是3个字节
----回顾----
二进制通过编码可以变为字符串，
字符串通过解码可以变为二进制
>>'哈哈'.encode('utf-8')
b'xe5x93x88xe5x93x88'
>>b'xe5x93x88xe5x93x88'.decode('utf-8')
'哈哈'
-----新东西-----
中国的游戏GBK编码后到日本的机器（Unicode）怎么玩？
"gbk编码的二进制byte".decode('gbk').encode('Unicode')把这个发给日本玩家就行了
注意：encode(Unicode)和decode(Unicode)可以省略，是自动的，万国码，每种语言的本来面目
Python2里需要s.decode('utf8').encode(gbk)
Python3默认所有字符都用Unicode编码
所以就直接：s.encode(gbk)就行了
注意：下面这里的gbk是文件的编码，s的编码还是Unicode
#-*-coding:gbk-*-
s = '你好'

散装知识点6：注释
注释：# ''' 多行 '''
也可以用'''表示多行的字符串

散装知识点7：字符串格式化输出
变量接收字符name = input("name:")
格式化输出，
1)字符串拼接，“name”+ name
2)info = '''
name:%s
age:%d
job:%s
salary:%f
'''%(name,age,job,salary)
%s字符串，%d数字，%f浮点
3)info = '''
name:{_name}
age:{_age}
job:{_job}
salary:{_salary}
'''.format(_name=name,_age=age,_job=job,_salary=salary)
4)info = '''
name:{0}
age:{1}
job:{2}
salary:{3}
'''.format(name,age,job,salary)

散装知识点8：密码不可见
import getpass
passwd = getpass.getpass("password:")
pycharm里面不行。脚本里面才行

散装知识点9：条件语句
if _username=username and _passwd=passwd:
print("成功")
elif 4==5:
print("失败")
else
print("oooo")

散装知识点10：while循环
while 条件1：
block1
else:
block2

条件1为真则一直执行block1，直到条件1为假，执行block2

散装知识点11：for循环
for i in range(0,10,2): 0到10步长2
block1
else:
block2

散装知识点12：break和continue
break结束循环
continue结束本次循环进入下一次循环

散装知识点13：模块初识，sys模块，os模块初识
模块，别人写的一堆功能，
标准库，不用安装直接导入
第三方库，必须下载安装才能用
import模块，先从当前模块下去找
-----------sys模块-----------------------
1)sys.path 是Python的环境变量。存放的一个一个路径，import的时候会从这些路径中去找
import先从当前目录找，因此import的时候，不能跟当前目录的.py重名
2)sys.argv 是取用户的输入参数的,第一个是模块的相对路径。例如./mod.py 1 2 3
sys.argv[0]为mod.py sys.argv[1]为1
-----------os模块----------------------
cmd = os.system("dir") cmd为0表示执行成功，不能存执行结果
cmd = os.popen("dir") cmd为对象的内存地址
res = os.popen("dir").read() res存放执行结果
os.mkdir("new_dir")
自己也可以写模块，自己写的模块调用的时候。
模块搜索路径：先从当前目录下找，找不到再去sys.path里面去找

散装知识点14：什么是pyc
系统自带的目录__pycache__
运行后会出现.pyc文件
pycodeobject是编译器真正的编译结果，运行结束将pycodeobject写入pyc
运行的时候直接加载pyc

散装知识点15：数据类型
1、整数
2、浮点型
3、布尔值True/False 1/0
4、字符串

散装知识点16：运算符
运算
+ +=
- -=
* *=
/ /=
% %=
** **=
// //=
==
!=
>=
<=
and or not
in not in
is is not type(a) is str
位运算
& 按位与
| 按位或
^ 按位异或
~ 按位取反
<<左移
>>右移

散装知识点17：三元运算
d=a if a>b else c
等价于 if a>b: d=a else: d=c

散装知识点18：bytes类型和String类型互相转换（略）

散装知识点19：列表，浅复制，深复制
存数据：list = ['a','b','c']
取数据：list[0]..list[-1]
切片：list[1:3]
取前三个：list[:3]=list[0:3]
取后三个：list[-3:]=list[-3:-1]
步长切片：list[::2]=list[0:-1:2] 从左向右步长2
步长切片：list[::-1]=list[0:-1:-1] 从右向左步长1
长度：len(names)
追加：names.append("ccc")
插入：names.insert(1,"fff")
修改：names[2]="jjjj"
按名称删除：names.remove("fff")
按下标删除：del names[2] = names.pop(2)
尾部删除：names.pop()不写是删最后一个
找下标：names.index("a")
清空：names.clear()
统计个数：names.count("a")
反转：names.reverse()
排序：names.sort()
扩展：names.extend(names2) #names2=[1,2,3,4]
浅复制三个方法：
1)name2 = names.copy()=copy.copy(names)
2)name2 = names[:]
3)name2 = list(names)
#只独立克隆第一层，如果列表套列表，第二层列表不变
深复制：
import copy
name2=copy.deepcopy(names)

散装知识点20：元祖
元祖，可以看做是只读列表，可以切片，可以查
names = ('zhangsan','lisi')
希望这些值不能被改变，可以用元祖，赋值可以直接：a,b=1,2

散装知识点21：低效访问列表
for index,item in enumerate(list_a):
print(index,item)

散装知识点22：字符串的方法
首字母大写>>name.capitalize()
统计字符个数>>name.count('a')
居中显示用减号填充>>name.center(50,'-')
字符串转为bytes>>name.encode('utf-8')
判断是否以ex字符结尾>>name.endswith('ex')
把字符串的一个tab转成30个空格>>name.expandtabs(tabsize=30)
找到字符fk的下标>>name.find('fk')
格式化字符串>>name.format(name='alex’,year=12)
格式化字符串>>name.format_map({'name':'alex','year':12})
是不是阿拉伯数字和阿拉伯字符>>name.isalnum()
判断是不是纯英文>>name.isalpha()
判断是不是10进制>>name.isdecimal()
判断是不是整数>>name.isdigit()
判断是不是一个合法变量名>>name.isidentifier()
判断是不是只有数字>>name.isnumeric()
判断是不是空格>>name.isspace()
判断是不是标题>>name.istitle()
字符串不存在打印不打印tty文件等不能打印>>name.isprintable()
判断是不是大写>>name.isupper()
列表变字符串用加号连接>>'+'.join(['1','2','3'])
字符串50长不足的左边星号补全>>name.ljust(50,'*')
字符串50长不足的右边星号补全>>name.rjust(50,'*')
大写变小写>>name.lower()
小写变大写>>name.upper()
去左边空格>>name.lstrip()
去右边空格>>name.rstrip()
去左右空格>>name.strip()
类似加密>>p = str.maketrans('abcdef','123456')
print('alex'.translate(p)) 打印1l5x
把2替换成a，只换一个>>name.replace('2','a',1)
找最右边的a字符的下标>>name.rfind('a')
按a为分隔把字符串变成列表>>name.split('a')
按换行符为分隔把字符串变成列表>>name.splitlines()
大写变小写，小写变大写>>name.swapcase()
字符串变成标题形式>>name.title()
50长度不够的用0填充>>name.zfill(50)

散装知识点23：字典
字典是key-value，可以通过key查value
字典有两个特点：无序和去重
dic = {"key1":"value1","key2":"value2"}
取value1：确定存在dic["key1"]，不确定存在dic.get("key1")
修改value1:dic["key1"]="value_one"
添加：dic["key3"]="value3"
删除key2：del dic["key2"]或者 dic.pop("key2")或者随便删一
个dic.popitem()
判断字典里是否有某个元素："key1" in dic
打印所有的key：dic.keys()
打印所有的value：dic.values()
如果有key3就返回，没有key3就创建：dic.setdefault
(key3,value3)
把两个字典合并，有交叉的合并，没有的创建：dic.update(dic1)
字典转成列表info.items()
初始化一个字典key为678values为"test"：dict.fromkeys
([6,7,8],"test")
这个有个坑：678三个key共享一个内存地址
-------------
res = dict.fromkeys([1,2,3],['m','n'])
print(res)
res[1][0] = 'p'
print(res)
-------------
{1: ['m', 'n'], 2: ['m', 'n'], 3: ['m', 'n']}
{1: ['p', 'n'], 2: ['p', 'n'], 3: ['p', 'n']}
如果改成res[1] = 'p'
就变成{1: 'p', 2: ['m', 'n'], 3: ['m', 'n']}
字典循环：
for i in info: 推荐，效率高
print(i,info[i])
for k,v in info.items():不推荐，这个吧字典转成列表要花时间
print(k,v)
多级字典嵌套：可以用来存放树状的数据结构

data = dict(A=1,b=2,C=3)
data.update(A=5,m=8)
print(data)    # {'A': 5, 'b': 2, 'C': 3, 'm': 8}
print(data.keys())  # dict_keys(['A', 'b', 'C', 'm'])

散装知识点24：集合
---------集合---------

初始化：set_1 = set([1,4,5,7,3])
集合最重要的两个特性：去重和关系测试
判断A和B有没有交集：A.isdisjoint(B)
子集：如果S是T的一个子集，即S.issubset(T)
父集：如果T是S的父集，即T.issuperset(S)
集合相等：
蓝:交集 A.intersection(B) 简写A&B
黄: 差集 A.difference(B) 简写A-B
绿：差集 B.difference(A) 简写B-A
黄+绿：对称差集 A.symmetric_difference(B) A^B
黄+蓝+绿：并集 A.union(B) 简写A|B
集合的基本操作>>
添加：set.add("item")
添加多项：set.update(["item1","item2","item3"])
删除:set.remove("item")
不报错删除：set.discard("item")
随机删除一个：set.pop()
长度：len(set)
判断是不是在集合里：x in set
浅复制：set.copy()

散装知识点25：文件操作
打开文件--操作--关闭文件
操作文件对象(文件句柄)：
f = open("yesterday","r",encoding="utf-8") r是以读模式打开
文件，读和写只能做一件事
data = f.read() 有内容，从第一个读到最后一个，f.read(5)读前五个
data2 = f.read()第二次读，无内容。指针从最后读不到内容
f.close()
-----
f = open("yesterday","w",encoding="utf-8") w是以写模式打开，从光标开头的地方开始写
文件，如果有重名会覆盖文件
f.write("12345 ")
f.write("上山打老虎")
f.close()
------
f = open("yesterday","a",encoding="utf-8")追加模式，不能读
，只能追加
-----
读前五行
for i in range(5):
print(f.readline())
循环文件
1)读小文件，全读到内存
for line in f.readlines():
print(line.strip())
2)内存里只保留一行，每次只处理一行效率最高的

for line in f:

　　print(line)

打印现在光标所在位置：print(f.tell())
光标回到开头：f.seek(0)
光标回到第10个字符：f.seek(10)
打印文件的编码：print(f.encoding)
f.seekable判断光标能不能移动，二进制文件等不能移动
强制从缓存刷到硬盘：f.flush()
-----
import sys,time
for i in range(50):
sys.stdout.write("#")
sys.stdout.flush()
time.sleep(0.1)
-----
f.truncate()不写就是清空文件
f.truncate(10)从开头往后截断10
以读和追加的形式打开: f=open("yesterday","r+",encoding="utf-8")
读是从头开始读，写是追加
打开新文件，写读方式打开，写是从头开始写，读可以随便读：
f=open("yesterday","w+",encoding="utf-8")
以二进制读f=open("yesterday","rb")，网络传输会用到
二进制写f=open("yesterday","wb") f.write("hello".encode())

怎样修改文件
1)把内容加载到内存，修改之后再写会到原文件
因为在硬盘是修改只能覆盖修改
2)逐行循环，边读边写
f = open("yesterday","r",encoding="utf-8")
f1 = open("yesterday_bak","w",encoding="utf-8")
for line in f:
if "text" in line:
pass
f1.write(line)
f.close()
f1.close()
-----with自动关闭文件
with open("file.txt","r","encoding=utf8") as f:
pass #执行完pass中的语句块后自动关闭文件
with open(..) as f1,open(...) as f2:
pass

散装知识点26：函数的定义和调用

---
def test(x):
x = 1
return x
---
返回值：
不写return，会隐式返回None
如果写return 1,'abc',['gg','mm']就返回元祖(1,'abc',['gg','mm'])
参数：
位置参数定义：def test(x,y) 调用 test(1,2) 或者 test(y=1,x=2)<==>test(2,1)
默认参数定义：def test(x,y=2)调用 test(5,6)/test(1)/test(7,y=8)
参数组(实参数目不固定)：
def test(*args) args为元祖 调用test(1,2,3,4...)
def test(**kwargs) kwargs为字典 调用test(name='alex',arg=8,sex='F')
kwargs={'name':'alex','age':8,'sex':'F'}
*args和**kwargs不传值就为空[]{}

散装知识点27：局部变量与全局变量

#school是全局变量，整个程序都起作用
school = "OldBoy edu."

def change_name(name):
    global school #我非要在局部作用域内改全局变量，需要用global关键字声明
    '''name是局部变量，作用域只在函数内生效'''
    print(name)
    name = "Alex"
    print(name)
    #school只在局部生效
    school = "MG Linux"
    print(school)

name = "alex"
change_name(name)
print("after",name)
print(school)
'''运行结果
alex
Alex
MG Linux
after alex
MG Linux
'''
'''
总结：
1、不能通过修改形参来改变实参的值
2、局部作用域内无法修改全局变量，除非用global关键字声明
'''

def change_name():
    global name
    name = "ALEX"
change_name()
print(name)
# 以上为错误做法！！
# 永远不要在函数里改全局变量。（不要在局部作用域内修改对象的引用）
# 因为调试的时候很难发现全局变量会在哪里被改了

names = ["alex","jack","rain"]
def change_names(names):
    names[0] = "金角大王"   #能改
    names = ["fff"]         #改不了
print(names)
change_names(names)
print(names)

'''
总结：
在局部变量里改对象的引用，是改不了的
在局部变量里改对象本身，是可以改的
'''

 散装知识点28：递归

'''
1、必须有明确的结束条件
2、每次进入更深一层，问题规模比上次有所减少
3、递归效率不高，递归层次过多会导致栈溢出
'''
def calc(age, times):
    if(times < 0):
        return age
    else:
        return calc(age+3,times-1)

print(calc(12,5))