python知识点汇总

一 变量类型

1.0 注释

# 单行注释

'''多行注释'''

"""多行注释"""

1.1 字符串

字典和字符串

字符串转字典：str1 = "{'key':1,'value':2}"eval()

01 内置函数eval()  实现str 和list tuple dict相互转化

# eval() 内置函数  str 和 list  tuple dict相互转化
data = "{'key1':'a','key2':2}"
str2dict = eval(data)
print("str2dict:   ",str2dict)  # {'key1': 'a', 'key2': 2}
print("str2dict数据类型是：  ",type(str2dict))  # <class 'dict'>

02 json.dumps()和json.loads()对简单的数据类型进行编解码

json编码中：python原始类型到json类型的转化对照表

# json.dumps() dict编码为json
dictD = {'key1': 'a', 'key2': 2}  --》{"key1": "a", "key2": 2}
dict2json = json.dumps(dictD)
print("dict2json:   ",dict2json)  # {"key1": "a", "key2": 2}
print("dict2json数据类型是：   ",type(dict2json))  # <class 'str'>

json解码中：json类型到python原始类型转化对照表

data2 = '{"key1":"c","key2":4}'# 里边只能是双引号，单引号会报错,如'{'a':1}'
json2dict = json.loads(data2)
print("json2dict:   ",json2dict)
print("json2dict数据类型是：   ",type(json2dict))

str='{'a':1}' 想转化成json格式,需要先转成dict
'{'a':1}'--》{'a':1}-->{"a":1}

{'a':1} = eval('{'a':1}')

{"a":1} = json.dumps({'a':1})

1.2 列表  list

列表的索引   取头不取尾

lst = ['a','b',1,0]

lst.append('c')     ['a','b',1,0.'c']

lst.pop(0)   ['b',1,0,'c']

lst[0]-->a;   lst[1:3]---> b ,1 ;   lst[:3] ---> a,b,1;   lst[1:] --> b, 1, 0;   lst[:] ---> a,b,1,0

lst[-1]-->0;  lst[-3:-1] --->b,1 ;   lst[:-1] --> a,b,1  ;   lst[-2:] ---> 1,0

lst[1:-1]-->b,  lst[-4:2]---> a,b

列表遍历

# 普通迭代
for i in lst:
    print(i)
# 带索引的迭代
for index,value in enumerate(lst):
    print("index: ",index,"value: ",value)

# 拓展场景(1）多列表迭代
# 	01 循环嵌套  缺点：代码复杂度高
xl,yl,zl = ['a'],['b'],['c']
for x in xl:
    for y in yl:
        for z in zl:
            print(z)
        print(y)
    print(x)

# 	02 intertools 标准库  缺点：不方便调试
from itertools import product
for x,y,z in product(xl,yl,zl):
    print(x,y,z)

# 拓展场景（2）交集、并集、补集
a=[2,3,4,5]
b=[2,5,8]
# 交集
ls1 = list(set(a).intersection(set(b)))
print("交集：",ls1)
# 并集
ls2 = list(set(a).union(set(b)))
print("并集：",ls2)
# 差集
ls3 = list(set(b).difference(set(a))) # b中有而a中没有的
ls4 = list(set(a).difference(set(b))) # a中有而b中没有的
print("以b为底，a的补集：",ls3)
print("以a为底，b的补集：",ls4)    

交集： [2, 5]
并集： [2, 3, 4, 5, 8]
以b为底，a的补集： [8]
以a为底，b的补集： [3, 4]

 1.3 元组 tuple

一旦创建，不可修改，但是两个元组之间可以合并

t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(t1+t2) # (1, 2, 3, 4, 5, 6)

注：元组和列表区别

列表是动态数组，内容和长度可变

元组是静态数组，内容和长度都不可变

元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。

1.4 字典 dict

取值

personinfo = {'name': 'joe', 'age':'20', 'hobby':'football'}
print(personinfo['name'])  # joe

遍历迭代

personinfo = {'name': 'joe', 'age':'20', 'hobby':'football'}
print(personinfo['name'])
print(personinfo.items())  # dict_items([('name', 'joe'), ('age', '20'), ('hobby', 'football')])
for k,v in personinfo.items():
    print(k,v)
# 结果    
name joe
age 20
hobby football

使用场景 

dict1 = {'a': 10, 'b': 8}
dict2 = {'d': 6, 'c': 4}
#合并/复制
dictMerge = {**dict1,**dict2}
print(dictMerge)
#增添字段
dict1 = {**dict1,'A':20}
dict2.update({'D':3})
print(("添加字段后 dict1是：%s  dict2是：%s") % (dict1,dict2))
# 重写字段的值
dict1 = {**dict1,'a':100}
print(dict1)

合并：{'a': 10, 'b': 8, 'd': 6, 'c': 4}
添加字段后 dict1是：{'a': 10, 'b': 8, 'A': 20}  dict2是：{'d': 6, 'c': 4, 'D': 3}
更改a的值为100： {'a': 100, 'b': 8, 'A': 20}

实用场景2： dict和json相互转换
import json
dict5 = {'a':1,'key':'v'}
dict2json = json.dumps(dict5)
json2dict = json.loads(dict2json)
print("dict2json值是： ",dict2json) # dict2json值是：  {"a": 1, "key": "v"}
print("json2dict值是： ",json2dict) # json2dict值是：  {'a': 1, 'key': 'v'}

1.5 拓展

isinstance: 用来判断对象的类型，也可以判断一个对象是否是一个类的实例

# 【常用场景1】:判断对象的类型
py_int = 1
py_str = 'a'
py_list = ['a','b']
py_dict = {'a':1,'b':2}
print(isinstance(py_int, int))

# 【常用场景2】:一个对象是否是一个类的实例
class C():
 pass
cc = C()
print(isinstance(cc, C))

# 运行结果
True
True

format: 用于组长和格式化数据

# 字符串
str1 = "{} {}".format("hello","world")  # 不指定位置
str2 = "{1} {0}".format("hello","world")  # 指定位置
print(str1,"\n",str2)
# 列表
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0}, 地址 {1}".format(my_list[0],my_list[1]))
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

# 字典
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{0}, 地址 {1}".format(site['name'],site['url']))
print("网站名：{name}, 地址 {url}".format(**site))

#运行结果
hello world 
 world hello
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com

二 语句 方法 类

2.1 条件语句

2.2 循环语句

while:

for :

for i in range():

range(start=0,stop,step=1) start 默认为0，step步长默认为1，

# step = 2
for i in range(0,5,2):
    print("步长为2 ",i)

# step = -2，
for i in range(8,0,-2):
    print("步长为-2 ",i) # 8，6，4，2

# 应用场景一：实现字符串倒序输出
name = "abc"
rename = ""
for i in range(len(name)-1,-1,-1):
    print(name[i])
    rename += name[i]
print(rename) # rename = "cba"

2.3 方法

2.4 类

# 创建类
class Employee
	empCount = 0
  	
    def __init__(self,name,salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

	def displayInfo(self):
      print "name: ",self.name,"salary: ",self.salary, "empCount； ",self.empCount
      
# __init__(),被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法      
# self 代表类的实例，代表当前对象的地址,self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
# self.__class__ 则指向类。

# 创建实例对象
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayInfo()  # 访问属性
empCounts = Employee.empCount

# 可以添加，删除，修改类的属性
emp1.age = 20
print(emp1.age) # 20
del emp1.age
print(hasattr(emp1,'age')) # False

hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age')    # 删除属性 'age'

单下划线、双下划线、头尾双下划线说明:

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。

• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

三 文件的读写和异常处理

3.1 文件的读写

file.truncate(size)  截取文件，截取的字节通过size指定，从首行开始截取，

size不填写则，默认为当前文件位置。 

f = open("main.py",'r+')
print(f.name)
# print(f.read(size))  size可有可无
# print(f.readline(size))  size可有可无， 读取整行包括 \n
print(f.readlines())  # ['\n', ' aaaaa']  每一行放入列表中
f.write("\n aaaaa")  # 返回的是写入字符串的长度
f.writelines()  # f.writelines(seq), seq必须是字符串列表["a \n","b"]如果需要换行则要自己加入每行的换行符。
f.close()
'''
r 只读，文件指针在开头
r+ 读写，文件指针在开头
w 只写，文件指针在开头，如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 读写，文件指针在开头，如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 只写，追加内容。文件指针在结尾，如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 读写，文件指针在结尾，如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
'''

with open("main.py","r") as f:
  print(f.readline())

3.2 异常处理

try:
    <statements>            # main action
except <name1>:             # 当try中发生name1的异常时处理
    <statements> 
except (name2, name3):      # 当try中发生name2或name3中的某一个异常的时候处理
    <statements>
except <name4> as <data>:   # 当try中发生name4的异常时处理，并获取对应实例
    <statements>
except:                     # 其他异常发生时处理
    <statements>
else:                       # 没有异常发生时处理
    <statements>
finally:                    # 不管有没有异常发生都会处理
    <statements>


def main():
    try:
        number1, number2 = eval(input("分别输入两个数字（用逗号隔开）："))
        result = number1 / number2
        print("它们的商是：", result)
    except ZeroDivisionError:
        print("除以0，错误！")
    except SyntaxError:
        print("数字间未输入逗号！")
    except:
        print("输入出错了！")
    else:
        print("没有错误！")
    finally:
        print("已执行完！")

main()

四 进程和线程

4.1 进程

4.2 线程

f"aaa{page}":https://blog.csdn.net/qq_35290785/article/details/90634344

GIL

生产者消费者爬虫

多线程数据通信  queue.Queue()

q.put()  q.get()会发生阻塞

当队列满的时候put不进去，

当队列空的时候，get不到元素

线程安全：

gil 也不能保证线程安全，https://zhuanlan.zhihu.com/p/311877485

CPython 中还有另一个机制，叫做 check_interval，意思是 CPython 解释器会去轮询检查线程 GIL 的锁住情况。每隔一段时间，Python 解释器就会强制当前线程去释放 GIL，这样别的线程才能有执行的机会。

关于github设置

pycharm 集成git  github

https://www.cnblogs.com/chenxiaomeng/p/14598391.html

https://blog.csdn.net/weixin_44505553/article/details/108800876?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_ecpm_v1~rank_v31_ecpm-3-108800876.pc_agg_new_rank&utm_term=%E6%97%A0%E6%B3%95%E5%B0%86git+%E8%AF%86%E5%88%AB%E4%B8%BAcmdlet&spm=1000.2123.3001.4430

error:   Failed to connect to 127.0.0.1 port 1080 after 2078 ms: Connection refused

https://blog.csdn.net/weixin_41010198/article/details/87929622

参考资料： 

https://mp.weixin.qq.com/s/vfxbNZcw6Uy4jFlI5VlmDA

https://www.runoob.com/python3/python-merging-two-dictionaries.html