python笔记
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python笔记,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含23912字,纯文字阅读大概需要35分钟。
内容图文
![python笔记](/upload/InfoBanner/zyjiaocheng/592/bc7177c7e12c4724848c4bdc78703fac.jpg)
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()
内容总结
以上是互联网集市为您收集整理的python笔记全部内容,希望文章能够帮你解决python笔记所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。