Python 列表的增删改查

print("hello world!")

list = ["王", "胡歌", "苍空", "小泽玛", "吴彦祖"]
td = ["1", "2", "3", "4", "2"]
num = [1, 6, 2, 1, 9, 6, 3, 5, 2, 3, 4, 5, 6, 1, 4, 8, 9]
list.append("吉吉国王")  # 默认在列表末尾添加
list.insert(2, "唐僧") # 添加在索引前面
list.extend(td)# 合并两个列表
list.pop(1)  # 默认删除最后一个列表值，可以删除特定索引的值
list.remove("2")  # 移除指定的值
dd = "王博文"
print(list.index(dd))  # 查询在列表中的索引
print(list.count("王博文"))  # 统计在列表出现多少次
num.sort()  # 排序
list.reverse()# 反转反转
list.copy()  # copy列表
list.clear()  # 清空列表
a = ["苍井空", "武藤兰"]
s = enumerate(a)  # 带下标的遍历
for i, k in s:
    print(i, k)

Python 字典的增删改查

dict = {"年龄": 33, "姓名": "苍井空", "身高": "156", "籍贯": "东京"}
dict2 = {"name": "hge"}
s = dict["姓名"]  # 查看所对应的值
dict["籍贯"] = "世界"  # 更改字典
# del dict["年龄"]  # 删除字典
if "身高" in dict:  # 查看字典是否在
    print("在")
else:
    print("不在")
print(dict.pop("年龄"))  # 返回删除的值
print(dict.items())  # 以列表返回可遍历的值
print(dict.popitem())  # 返回最后一个劲键值对
print(dict.values())  # values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值
print(dict.get(("年龄"), 12))  # get() 函数返回指定键的值，如果键不在字典中返回默认值
dict.update(dict2)  # 更新字典
# 关于字典中 get() 和 setdefault() 的区别：
# 主要在于当查找的键值 key 不存在的时候，setdefault()函数会返回默认值并更新字典，添加键值；而 get() 函数只返回默认值，并不改变原字典。
dict.setdefault("age", 23)  # 如果键不已经存在于字典中，将会添加键并将值设为默认值
dict3 = dict.fromkeys(dict, 3)
x = ("key1", "key2", "key3")
this = dict.fromkeys(x, 3)
print(this)

Python 字符串操作

a = "hello world"
b = "四"
b1 = "Ⅵ"
# 定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可
c = u"112345"
d = "     wang    "
print(a.ljust(30, "*"))  # 右边填充30个字符长度
print(a.center(30, "*"))  # 两边各自填充15个字符长度
print(a.rjust(30, "*"))  # 左边填充30个字符长度
print(a.isalnum())  # 检测是否有数字和字母组成不包含符号
print(a.islower())  # 是否全是小写
print(a.isalpha())  # 是否只由字母组成
print(a.isdigit())  # 是否只由数字组成
print(b.isnumeric())  # 可以测试是否由汉语数字组成
print(c.isnumeric())  # 检测字符串是否只由数字组成。这种方法是只针对unicode对象
print(a.isspace())  # 检测字符串是否只由空格组成
print(a.istitle())  # 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
print(a.isupper())  # 检测字符串中所有的字母是否都为大写
print(b.join(a))  # 序列中的元素以指定的字符连接生成一个新的字符串
print(d.lstrip())  # 去掉右边的空字符串，形成新的字符串
print(d.rstrip())  # 去掉左边的空字符串，形成新的字符串
print(d.strip())  # 去掉所有空格
print(a.replace("l", "w", 2))  # 替代操作
str = "welcom to china!"
dd = "china!"
ff = "wel"
print(str.endswith(dd))  # 以china结尾
print(str.startswith(ff))  # 以wel开头
# format拆包列表
a = ["wa", "ah", "ha"]
print("hell{},he2{},he3{}".format(*a))
# format拆包字典
a = {"wang": "bowen", "age": 18, "addr": "henan"}
print("wojiao:{wang},zhuzai{addr},jinnian{age}".format(**a))
# eval()可以执行字符串中的命令

Python 随机数

from random import *

list = ["王博文", "胡歌", "苍井空", "小泽玛利亚", "吴彦祖"]
num = random()  # 产生 0 到 1 之间的随机浮点数
num = randint(1, 10)  # 产生1-10之间的整数
num = randrange(1, 100, 10)  # 生成从1到100的间隔为10的随机整数
num = uniform(1, 10)  # 生成1-10之間的随机小数)
number = [1, 3, 4, 3, 5, 7, 8, 4, ]
shuffle(number)  # 打乱列表顺序
x = sample(list, k=2)  # 从list中随机选出两个
y = choice(list)  # 选出一个不带符号的值
z = choices(list, cum_weights=[0, 0, 1, 0, 0], k=5)
# 可以设置k值，weightsweights：相对权重 cum_weights：累加权重

Python 集合操作

# 集合是无序的不重复的
jihe = {"吴彦祖", "小泽玛利亚", "胡歌", "古灵", "武藤兰", "金庸", "吴耀祖", "景天", "苍井空"}  # 集合去重
jihe2 = {"东皇太一", "苍井空", "吴彦祖", "刘德华", "鲁班七号"}
print(jihe.pop())
jihe.add("苍井空")

jihe3 = jihe.difference(jihe2)  # difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中
# 但不包含在第二个集合(方法的参数)中。
# ---------------------------------------------------------#
# jihe.difference_update(jihe2)  # difference_update() 方法用于移除两个集合中都存在的元素
# difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，
# 而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
jihe.discard("胡歌")  # discard() 方法用于移除指定的集合元素。
# 该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会
jihe.remove("景天")  # remove() 方法用于移除集合中的指定元素。
jihe4 = jihe.intersection(jihe2)  # intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。
jihe5 = jihe.isdisjoint(jihe2)  # isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
jihe6 = jihe.issubset(jihe2) # issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False
jihe7 = jihe.issuperset(jihe2)  # issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False
jihe8 = jihe.symmetric_difference(jihe2)  # symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素
jihe.symmetric_difference_update(jihe2)  # symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，
# 并将另外一个指定集合中不同的元素插入到当前集合中。
jihe.union(jihe2)  # union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次
# ###
# >>> # 下面展示两个集合间的运算.
# ...
# >>> a = set('abracadabra')
# >>> b = set('alacazam')
# >>> a
# {'a', 'r', 'b', 'c', 'd'}
# >>> a - b                              # 集合a中包含而集合b中不包含的元素
# {'r', 'd', 'b'}
# >>> a | b                              # 集合a或b中包含的所有元素
# {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
# >>> a & b                              # 集合a和b中都包含了的元素
# {'a', 'c'}
# >>> a ^ b                              # 不同时包含于a和b的元素
# {'r', 'd', 'b', 'm', 'z', 'l'}
# ###
#类似列表推导式，同样集合支持集合推导式(Set comprehension):
# >>> a = {x for x in 'abracadabra' if x not in 'abc'}
# >>> a
# {'r', 'd'}

Python eval和json的使用

a = 'input("请输入你的命令：")'
eval(a)  		#可以执行字符串中的命令
json.dumps() 	#对数据进行编码，
json.loads() 	#对数据进行解码。
repr() 			#函数将对象转化为供解释器读取的形式
json里将数据持久化有两个方法：
#dumps：将数据转换成为json字符串，不会将数据保存在文件中
#dump：将数据转换成为json字符串的同时保存在指定的文件中
json里将数据反序列化两个方法：
#loads:将json字符串加载成为pyhton里的数据
#load：读取文件，把读取的内容加载成为python里的数据

Python pickle模块的使用

pikcle的作用是编码和解码
pikcle的四种方法:
dump    对文件中的内容进行编码的方式操作
load    对文件中的内容进行解码操作
dumps   将内容编码成二进制的方式
loads   将内容从二进制上进行解码

'''
#先进行调用pikcle模块
# import pickle
# list1=[1,2,3,4]
# res=pickle.dumps(list1) #:将列表内容转换成二进制
# print(res)
# res1=pickle.loads(res)
# print(res1)


#使用pikcle对文件进行写读操作(二进制)
#注意必须要使用二进制的方式进行操作
# import  pickle
# with open("yangceshi1.txt","wb") as file1:
#     pickle.dump("天上天下，人来人往",file1)
# with open("yangceshi1.txt","rb") as file1:
#     res=pickle.load(file1)
#     print(res)
# import pickle# list1=[1,2,3,4]
# res=pickle.dumps(list1) #:将列表内容转换成二进制
# print(res)# res1=pickle.loads(res)
# print(res1)
#使用pikcle对文件进行写读操作(二进制)#注意必须要使用二进制的方式进行操作# import  pickle# with open("yangceshi1.txt","wb") as file1:
#     pickle.dump("天上天下，人来人往",file1)# with open("yangceshi1.txt","rb") as file1:
#     res=pickle.load(file1)
#     print(res)python

Python json和pickle的区别

pickle可以在python之间进行交互
json可以实现python与不同开发语言的交互
pickle可以序列化python中的任何数据类型
json只能序列化python中的常归数据类型（列表等）
pickle序列化后的对象不可读
json序列化后的对象是可读的

Python os模块

import os

print(os.name)  # 获取当前操作系统平台
print(os.getcwd())  # 获取当前工作目录
print(os.getcwdb())  # 获取当前工作目录，以Unicode返回
print(os.system("net use"))  # 运行shell命令
print(os.listdir())  # 获取某个目录下的所有文件名
# os.remove("ss.html")  # 删除指定的文件
print(os.path.exists("d:\\"))  # 检验给出的路径是否存在
print(os.path.isfile("test.py"))  # 判断是否为文件，若是，返回为真
print(os.path.abspath("test.py"))  # 返回绝对路径
print(os.path.realpath("test.py"))  # 返回真实路径
print(os.path.isdir("venv"))  # 判断是否为目录，若是，返回为真
print(os.path.splitext("test.py"))  # 分离文件名与扩展名
print(os.path.split(r"E:\pycharm\day\test.py"))  # 把一个路径拆分为目录+文件名的形式
print(os.path.join("dd", "test.py"))  # 连接目录与文件名或目录
print(os.path.basename(r"E:\pycharm\day\test.py"))  # 返回文件名
print(os.path.dirname(r"E:\pycharm\day\test.py"))  # 返回路径名
os.chdir("d:\\")  # 改变工作目录

Python sys模块

import sys

print(sys.argv)  # 命令行参数List，第一个元素是程序本身路径
print(sys.version)  # 获取python版本信息
print(sys.path)  # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
print(sys.modules)  # 返回系统导入的模块字段，key是模块名，value是模块
# sys.stdout.write('please:')
# sys.stdin.readline()[:-1]
print(sys.modules.keys())  # 返回所有已经导入的模块名
print(sys.modules.values())  # 返回所有已经导入的模块
print(sys.base_prefix)  # 返回python解释器路径
print(sys.platform)  # 返回操作系统类型
print("请输入你的名字：")
name = sys.stdin.readline().strip()
sys.stderr.write("你的名字是：{}".format(name))
# 使用 sys.stderr 可以获取标准错误的文件句柄对象，
# 将 sys.stdout 中示例中的 stdout 替换为 stderr 即可。
sys.getdefaultencoding()  # 获取当前系统的编码
sys.exit(100)	#退出码为100

Python time hashlib uuid模块

import time
import uuid
import hashlib

localtime = time.localtime(time.time())
localtime = time.asctime(time.localtime(time.time()))  # 格式化时间
print("本地时间为 :", localtime)
print(time.perf_counter())  # 返回系统运行时间
print(time.process_time())  # 返回进程运行时间
print(uuid.uuid1())  # uuid1()——基于时间戳
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'testme'))  # uuid3()——基于名字和MD5散列值
print(uuid.uuid4())  # uuid4()——基于随机数
print(uuid.uuid5(uuid.NAMESPACE_DNS, 'testme'))  # uuid5()——基于名字的SHA-1散列值
#######hashlib#########
md = hashlib.md5()  # 将hashlib.md5的算法赋值给md
md.update("你好".encode('utf-8'))  # 先将你好这个字符串以utf-8编码转换成bytes(字节)格式，再存入到md变量中，因为update中只能存入bytes(字节)
md = md.hexdigest()  # hexdigest(…) 以16进制形式返回加密内容 digest() 以字符串形式返回
print(md)

Python 装饰器及高级用法

# 定义一个装饰器
def clock_game(fn):
    # clock_game为装饰器名字
    def clock(x, y, *args, **kwargs):
        # if args[0] >= 18:
        # clock = kwargs['clock']
        clock = kwargs.get('clock', 30)
        # kwargs.get 如果不定义clock，就使用默认值，30
        if clock >= 18:
            fn(x, y)

        else:
            print("Go Out")

    return clock


# 以上为装饰器的基本结构

@clock_game  # 使用的装饰器后 play_game=clock_game(play_game),所以fn等于play_game
def play_game(name, game):
    print("{}正在玩{}".format(name, game))


play_game("张三", "王者荣耀", clock=3)
# 当使用了装饰器后，play_game调用的是clock函数，
# 此时的 张三 对应clock中的x，王者荣耀 对应clock中的y
#

#高级装饰器的用法
给装饰器加参数
user=6
read_permission=4
def check(x, y):
    def handle(fn):
        def do():
            fn()
        return do
    return handle

@check(user, read_permission)
def read():
    print("我在读取内容")

read()

Python 魔法方法

if __name__ == '__main__':
    print("name",__name__)
__name__:当直接运行的时候，值是__main__
如果这个py文件作为一个模块导入的时候，值是文件名
__slots__=()
这个属性直接定义在类里，是一个元组，用来规定对象可以存在的属性
__init__：创建对象时调用
__del__：销毁对象时调用
__repr__:当打印一个对象是会调用这个对象的__str__或者__repr__方法
__str__:如果两个方法都写了，选择__str__
__call__: 使用p() call方法调用
__eq__：调用比较方法

Python 类和对象

类和对象是面向对象编程的俩个核心概念
类是对一群具有相同特征或者行为的事物的一个统称
特征就是一个变量，在类中称为属性
行为就是一个函数，在类中成为方法
类就是由属性和方法组成的一个抽象概念
定义类：
class person:
    __slots__=('name','age')
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def names(self):
        print("我的名字是{},我的年龄是{}".format(self.name, self.age))


s1 = person("wang", 18)
s1.names()

*Python args和**kwargs

打包（pack）：*args是把多个位置参数打包成元组，**kwargs是把多个关键字参数打包成字典。 
拆分（unpack）：*args是把打包了的参数拆成单个的，依次赋值给函数的形参，**kwargs是把字典的键值拆成单个的，依次赋值给函数的形参。
def foo(a,b,*args):
    print("a=",a)
    print("b=",b)
    print("c=",args)
foo(1,2,3,4,5)
a= 1
b= 2
c= (3, 4, 5)
def foo(**kwargs):
    print(kwargs)
foo(a=1,b=2,c=3)
{'a': 1, 'b': 2, 'c': 3}
def bar(a, b, c):
    print(a,b,c)
 
 
bar(**{'a': 1, 'b': 2, 'c': 3}) 
1 2 3

Python 类方法和静态方法

静态方法：没有用到实列对象的任何属性
class test:
    def __init__(self, name, age):
        self.age = age
        self.name = name

    @staticmethod
    def demo():
        print("hello")


p1 = test("张三", 18)
test.demo()
p1.demo()
静态方法使用
class test:
    @staticmethod
    def demo(a, b):
        return a + b
print(test.demo(1, 4)) 
类方法：如果一个方法只用到了类属性，我们可以定义为一个类方法
class test:
    type = "demo"

    @classmethod
    def demo(cls):
        print("类方法")
        print(cls.type)


test.demo()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bax1cgps-1618461759756)(C:\Users\11063\AppData\Roaming\Typora\typora-user-images\image-20201025145535288.png)]

Python 单例设计模式

单例设计模式，是通过重写__new__方法，使之只能调用一次内存
class test(object):
    __instance = None  # 类属性
    __is_first = True

    @classmethod
    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
            # 申请内存，创建一个对象，并把对象的类型设置为cls
            # instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, a, b):
        if self.__is_first:
            self.a = a
        	self.b = b
       	 	self.__is_first = False


s1 = test("hh", "xx")
s2 = test("mm", "tt")
print(s1 is s2)
print(s1.a)

Python 继承

面向对象的编程有三大特性：；封装，继承，多态
封装：函数是对语句的封装，类是对函数和变量的封装
继承：类和类之间可以手动的建立父子关系，父类的属性和方法，子类可以使用
多态：是一种技巧，提高代码的灵活度
继承特点：如果一个类A继承自类B，由类A创建出来的实例对象，类B都可以直接使用
继承的使用：
class animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name + "正在睡觉")


class dog(animal):
    def bark(self):
        print(self.name + "正在叫")


class student(animal):
    def study(self):
        print(self.name + "正在好好学习")
###dog() 调用__new__方法,再调用__init__方法
###dog 里没有__new__方法，会查看父类是否重写__new__方法方法
###父类里也没有重写__new__方法，查看父类的父类，找到objec

###调用__init__方法，dog类没有实现，会自动找animal类
d1=dog('大黄',3)
print(d1.name)#父类里定义的属性
d1.sleep()#父类的方法，子类实例对象可以直接使用
d1.bark()
d2 = student("小米", 13)
d2.study()
d2.sleep()


继承的特点
class A(object):
    def demo_a(self):
        print("我是A类里的方法demo_a")

    def foo(self):
        print("我是A类里的方法foo")


class B(object):
    def demo_b(self):
        print("我是A类里的方法demo_b")

    def foo(self):
        print("我是B类里的方法foo")


class C(A, B):
    pass


c = C()
c.demo_a()
c.demo_b()

# python里允许多继承，如果有多个同名方法，有一个类属性可以查看调用的顺序
c.foo()
print(C.__mro__)  ##(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
 
python 私有属性的继承特点
自己类里定义的私有方法		对象名._类名.__私有方法名
父类的私有方法，子类没有继承	
可以通过	对象名._父类名.__私有方法名

Python is和isinstance的使用

is 和 isinstance的区别 and issubclass
定义一个子类和父类

1
2
3
4
class A:
    pass
class B(A):
    pass
　　

is

1
2
3
4
5
print(type(b) is B)
# 结果: True
 
print(type(b) is A)
# 结果: False
is 通过"type"可以判断两个类型是否相等, 只会判断绝对相等, 而不去关心父类是谁.

 

isinstance

1
2
3
4
print(isinstance(b, B))
#结果: True
print(isinstance(b, A))
#结果: True
isinstance 会对这个对象进行"刨祖坟"式的判断, 先判断本类, 在判断父类, 一直判断, 直到object

 

issubclass

1
2
3
4
5
6
7
8
9
10
11
12
class A:
    pass
class B(A):
    pass
class C(B):
    pass
 
print(issubclass(C, B))
# 结果: True
 
print(issubclass(C, A))
# 结果: True
 

判断一个类是否是另外一个类的子类, 也是"刨祖坟"式的判断

python 子类重写父类方法

子类在父类实现的基础上，又添加自己的新功能
#调用父类方法的两种方式
1.父类名。方法名(self,参数列表)
person.__init__(self,name,age)
2.使用super直接调用父类的方法，推荐是用此方法
super（student,self）.__init__(name,age)
self.shchool = school

Python 多态的使用

多态是基于继承，通过子类重写父类的方法，
达到不同的子类对象调用相同的父类方法，得到不同的结果
提高代码的灵活度

Python 文件操作

filename = "bestand.py"

with open(filename) as f:
    content = f.readlines()

for line in content:
	print(line)
代码的第一部分将读取文件内容。 读取的所有行将存储在变量内容中。 第二部分将遍历变量内容中的每一行。

如果您不想读取换行符"\n"，则可以将语句f.readlines()更改为此：

content = f.read().splitlines()

当上面的代码起作用时，我们应该始终测试要打开的文件是否存在。 我们将首先测试文件是否不存在，如果存在，它将读取文件，否则返回错误。 如下面的代码：
import os.path

filename = "bestand.py"

if not os.path.isfile(filename):
    print('File does not exist.')
else:
with open(filename) as f:
    content = f.read().splitlines()


for line in content:
    print(line)

    
Python 默认支持写文件，不需要特殊模块。 您可以使用.write()方法以及包含文本数据的参数来写入文件。

在将数据写入文件之前，请调用open(filename, 'w')函数，其中filename包含文件名或文件名的路径。
filename = "newfile.txt"
myfile = open(filename, 'w')
myfile.write('Written with Python\n')
myfile.close()
r	打开文件以供读取
w	打开文件进行写入（将截断文件）
b	二进制更多
r+	打开文件进行读写
a+	打开文件进行读写（附加到结尾）
w+	打开文件进行读写（截断文件）

Python csv文件的读写

写：
import csv

file = open('demo.csv', 'w', encoding='utf8')
w = csv.writer(file)
w.writerows(
    [
        ['张三', '性别', '年龄'],
        ['张三', '性别', '年龄'],
        ['张三', '性别', '年龄'],
    ]
)
读：
import csv

file = open('info.csv', 'r', encoding='utf-8', newline='')
r = csv.reader(file)
for data in r:
    print(data)
file.close()

Python 将数据写入到内存

from io import StringIO

s_io = StringIO()
s_io.write('hello')
s_io.write('good')
print(s_io.getvalue())

Python 序列化和反序列化

#序列化：将数据从内存持久化保存到硬盘的过程

#反序列化：将数据从硬盘加载到内存的过程

python 异常处理

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

Python finally和with关键字的使用

不论try中写文件的过程中是否有异常，finally中关闭文件的操作一定会执行。由于finally的这个特性，finally经常被用来做一些清理工作。
try:
    print ("i")
finally:
    print ("不管上面是否异常，我必须输出")
    
    
with表达式其实是try-finally的简写形式。但是又不是全相同。
"""
格式
with context [as var]:
    pass
"""
"""
with 语句实质是上下文管理。
1、上下文管理协议。包含方法__enter__() 和 __exit__()，支持该协议对象要实现这两个方法。
2、上下文管理器，定义执行with语句时要建立的运行时上下文，负责执行with语句块上下文中的进入与退出操作。
3、进入上下文的时候执行__enter__方法，如果设置as var语句，var变量接受__enter__()方法返回值。
4、如果运行时发生了异常，就退出上下文管理器。调用管理器__exit__方法。
"""

自定义类必须包含上述几个方法才能正确使用with关键字。


class Mycontex(object):
    def __init__(self,name):
        self.name=name
    def __enter__(self):
        print("进入enter")
        return self
    def do_self(self):
        print(self.name)
    def __exit__(self,exc_type,exc_value,traceback):
        print("退出exit")
        print(exc_type,exc_value)
if __name__ == '__main__':
    with Mycontex('test') as mc:
        mc.do_self()

Python 自定义异常

raise语句
主动抛出异常。
格式：
主动抛出异常终止程序
raise 异常名称(‘异常描述’)

raise RuntimeError('testError')

#最简单的自定义异常
class FError(Exception):
    pass


抛出异常、用try-except抛出

try:
    raise FError("自定义异常")
except FError as e:
    print(e)
    
    
在这里给一个简单的自定义异常类模版。

class CustomError(Exception):
    def __init__(self,ErrorInfo):
        super().__init__(self) #初始化父类
        self.errorinfo=ErrorInfo
    def __str__(self):
        return self.errorinfo

if __name__ == '__main__':
    try:
        raise CustomError('客户异常')
    except CustomError as e:
        print(e)

Python 可迭代对象和迭代器

from collections.abc import Iterable
name = []
print(isinstance(name, Iterable))	#True
##只要重写了__iter__方法，就是一个可迭代对象
根据循环的原理可以重写迭代器
每一次for循环都会使用__next__方法
d=domo(10)
i=d.__iter__()
i.__next()
i=iter(d)#内置函数 就是调用上面的iter方法

Python 生成器的使用

nums = [i for i in range(10)]  # 列表生成式（推导式）
print(nums)		#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
g = (i for i in range(10))  # 得到的结果是生成器
print(g)	#<generator object <genexpr> at 0x01D45450>
for m in g:	#生成器是一个特殊的迭代器，也可以用在for...in...后面
    print(m)
yield #将函数变成生成器    
迭代器是一个对象，定义class
生成器写法上像一个函数
https://www.runoob.com/python3/python3-iterator-generator.html

Python socket套接字

import socket
UDP发送数据
# 创建socket并连接
# AF_INET:表示这个socket是用来进行网络连接
# SOCK_DGRAM：表示连接是一个udp连接
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 发送数据
# data:要发送的数据，他是二进制数据
# address:发送给谁 参数是一个元组，元组里有两个元素
# 第0个表示目标的ip地址，第一个表示程序的端口号
# 给47.115.158.105 这台主机的9090端口发送消息
s.sendto('heloo'.encode('utf-8'), ('47.115.158.105', 9090))
s.close()
UDP接收数据
import socket

# 创建一个基于udp的网络socket连接
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口号和ip地址
s.bind(('192.168.3.81', 9090))
# recvfrom 接收数据
data, addr = s.recvfrom(1024)
# print(content)
print('从{}地址端口号接受到了消息，内容是：{}'.format(addr[0], addr[1], data.decode('utf8')))
# 接受到的数据是一个元组，元组里有俩个元素
# 第0个元素是接收到的数据，第一个元素是发送方的ip地址和端口号
s.close()


#TCP客户端
import socket
#基于tcp协议的socket连接
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('192.168.3.95',9090))
s.send('halou'.encode('utf8'))
s.close()
#TCP服务器
import socket

# 基于tcp协议的socket连接
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('192.168.3.95', 9090))
s.listen(128)  # 把socket变成一个被动监听的socket
client_socket, client_addr = s.accept()
# 接收客户端的请求,接收到的结果是一个元组，元组里有俩个元素，第0个是socket连接。第1个是客户端的ip地址和端口号
# (<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('192.168.3.95', 9090), raddr=('192.168.3.81', 27928)>, ('192.168.3.81', 27928))
data = client_socket.recv(1024)
print('接收到了客户端{}端口号{}发送的数据，内容是:{}'.format(client_addr[0], client_addr[1], data.decode('utf8')))

s.close()

###文件下载案例####
####服务器
import socket
import os

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('192.168.3.81', 9090))
server_socket.listen(128)
client_socket, client_addr = server_socket.accept()
data = client_socket.recv(1024).decode('utf8')
if os.path.isfile(data):
    with open(data, 'r', encoding='utf8') as file:
        content = file.read()
    client_socket.send(content.encode('utf8'))
else:
    print('文件不存在')


####客户端
import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('192.168.3.81', 9090))
file_name = input('请输入你要下载的文件名：')
s.send(file_name.encode('utf8'))
content = s.recv(1024).decode('utf8')
with open(file_name, 'w', encoding='utf8') as file:
    file.write(content)
s.close()

Python 多线程

# 多线程多任务实现方法
import threading
import time


def dance():
    for i in range(10):
        time.sleep(1)
        print("dancing")


def sing():
    for i in range(10):
        time.sleep(1)
        print("singing")


t1 = threading.Thread(target=dance)
t2 = threading.Thread(target=sing)
t1.start()
t2.start()
创建锁
lock=threading.Lock()
lock.acquire()
lock.release()

线程间通信 queue
线程名=queue.Queue()
线程使用：
q.put()
q.get()
先进先出

Python 多进程的使用

# 多进程的使用
import multiprocessing, time


def dance():
    for i in range(n):
        time.sleep(0.5)
        print("正在跳舞")


def sing():
    for i in range(m):
        time.sleep(0.5)
        print("正在唱歌")


if __name__ == '__main__':
    # 创建两个进程
    # target用来表示执行的任务
    # args 用来传参。类型是一个元组
    p1 = multiprocessing.Process(target=dance, args=(20,))
    p2 = multiprocessing.Process(target=sing, args=(50,))
    p1.start()
    p2.start()