一、Python基础
1、程序入口
def print_hi():
# 控制台打印输出hello world
print("hello world")
#程序入口
if __name__ == '__main__':
print_hi()
2、类型
1、查看类型type
print(type(1))
2、强制类型转换
print(float(1))
3、字符串
#三种字符串
s1="zhangsan"
s2='zhangsan'
s3="""zhangsan"""
print(type(s1))
print(type(s2))
print(type(s3))
4、字符串拼接/格式化
s1="zhangsan"
s2='lisi'
print("%s和%s是邻居" % (s1, s2))
print(f"{s1}和{s2}是邻居")
print("%2d"%11.1)
#小数点前两位整数,一位小数
print("%2.3f" % 11.1)
3、输入
s3=input("请输入");
print(s3)
4、for循环
s1="zhangsan"
for s in s1:
print(s)
5、序列
#获取随机数
print(random.randint(2, 53))
#获取从2到6序列,步长为2
for x in range(2, 6,2):
print(x)
6、函数
def print_hi():
print("hello world")
def sum(a,b):
return a+b
当函数调用时指定形参,可以乱序传参
函数形参可以设置默认值,但最后一个参数必须有默认值
def f1(name,age=33,sex='男'):
print(f"名字{name},年龄{age},性别{sex}")
if __name__ == '__main__':
f1(age=11,sex='男',name='lisi')
不定长参数/可变参数
#参数位置为元组类型
def f2(*args):
print(args)
#参数位置为字典类型
def f3(**kargs):
print(kargs)
if __name__ == '__main__':
f2(11,'男','lisi')
f3(age=11,sex='男',name='lisi')
函数作为参数传递
def sum(a,b):
return a+b
def f4(sum):
print(sum(1,2))
使用lambda表达式调用
f4(lambda x,y:x+y)
7、容器
list、tuple、str、set、dict,具体方法查看源码
list=['dsa','dsaf',1]
print(type(list))
#元组内容无法修改,但嵌套的list可以修改
t2=(1,'dsa',1.9)
t=tuple()
print(type(t),type(t2))
#set集合无序,不能重复
s1={'dsaf',22,3.4,22}
s2=set()
print(s1)
#字典为键值对,key不能重复
dict1={'name':'zhangsan','age':11}
dict2=dict()
print(dict1['name'])
8、文件操作
1、文件读取
t = open("E:\\learn\\PythonBasic\\testOpen.txt", "r", encoding="UTF-8")
print(t.readline(1))
print(t.read())
t.close()
#自动调用close方法
with open("E:\\learn\\PythonBasic\\testOpen.txt", "r", encoding="UTF-8") as f:
print(f.readlines())
2、文件写入
#w为覆盖写
with open("E:\\learn\\PythonBasic\\testOpen.txt", mode='w', encoding="UTF-8") as f:
f.write("hahaha")
f.flush()
3、创建及追加
with open("E:\\learn\\PythonBasic\\testOpen1.txt", mode='a', encoding="UTF-8") as f:
f.write("你好")
f.flush()
9、异常
异常捕获使用except
try:
f=open("E:\\learn\\PythonBasic\\testOpen2.txt", mode='r', encoding="UTF-8")
except:
print("文件不存在")
捕获指定异常
try:
a=1/10;
except ZeroDivisionError as e:
print("除法不合法")
else:
print("无异常发生")
finally:
print("程序最后一定要执行")
10、自定义模块导入
import testImport
from testImport import *
上面代码导入会受到包中__all___=[]的限制,影响函数正常导入。只有在[]内的函数才能导入
11、Python包
包=模块+init文件
12、json数据转换
data=[{'name':'lilei','age':12}, {'name':'zhangsan','age':15},{'name':'zhaowu','age':53}];
s=json.dumps(data)
print(type(s))
print(type(json.loads(s)))
13、Python对象
建议对比Java对象学习,理解更加深刻
class Student:
name=None;
age=None
gender=None
def printA(self):
print(self.name)
# 相比于Java,Python不需要写new
stu1=Student()
# 对象直接print也打印出地址
print(stu1)
# 默认的public直接用.
stu1.name="lisi"
print(stu1.name)
成员方法定义
def 方法名(self,形参1,...,形参n):
方法体
与Java不同,self关键字在成员方法定义时必写
- self表示对象自身
- 调用方法时self自动传入,不用写
- 方法内部使用成员变量必须用self,类似于Java中的this
构造方法:
有参构造
class Student:
# 初始化
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender
__str__
(Java的toString方法,不重写默认输出地址)
class Student:
# 初始化
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender
def __str__(self):
return str(self.name)+str(self.age)+str(self.gender)
__eq__
与Java中toEquals类似,通过重写进行比较,不写默认比较地址
私有成员变量/方法
以__开头即为私有,Java中为private,私有只有类内部可以使用,类对象无法使用
class Student:
__tel=3
# 初始化
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender
def __str__(self):
return str(self.name)+str(self.age)+str(self.gender)
def __firstStep(self,a):
return a+1
def secondStep(self):
return self.__firstStep(3) + 1
14、Python魔术方法
在Python中,所有以双下划线__
包起来的方法,统称为Magic Method(魔术方法),它是一种的特殊方法,普通方法需要调用,而魔术方法不需要调用就可以自动执行。
Python中初始化和构造分别使用init和new,初探:
class People(object):
# 创建对象
def __new__(cls, *args, **kwargs):
print("触发了构造方法")
ret = super().__new__(cls) # 调用父类的__new__()方法创建对象
return ret
# 初始化化对象
def __init__(self, name, age):
self.name = name
self.age = age
print("初始化方法")
# 删除对象
# del 对象名或者程序执行结束之后
def __del__(self):
print("析构方法,删除对象")
def __call__(self, num):
self.p=num
return (self.p )
def __str__(self):
return str(self.p)
if __name__ == '__main__':
p1 = People('lisi', 43)
print(p1(2))
常用的魔术方法:
1、__new__
实例化对象时自动触发,在__init__
之前,参数至少有一个cls 接收当前类,其他参数根据初始化方法参数决定,用于实例化对象,返回一个对象实例。但是实例化是由Object实现,其他只不过是继承了Object
2、__init__
实例化对象之后立即触发,参数至少有一个self,接收当前对象,其他参数根据需要进行定义,用于初始化对象,无返回值
3、__del__
当该类对象被销毁时自动触发,参数为self来接收对象,无返回值
4、__str__
使用print(对象)或者str(对象)的时候触发,参数为self,返回值为字符串,一般用其打印有意义的信息,默认打印返回对象地址
5、__call__
将对象当作函数调用时触发
其他现用现查
15、继承
继承分为单继承和多继承,不能继承私有的。Java只有单继承,多继承可通过接口实现
单继承:
class 类名(父类名):
类内容体
多继承:
class 类名(父类名1,父类名2,...,父类名N):
类内容体
多继承的成员同名时,只保留最左侧的父类的
子类可以通过同名来重写父类的成员,如想在子类中使用父类成员要使用super()或者父类名
16、类型注解和Union类型
对形参进行类型注解
def add(x :int,y:int):
print(x+y)
Union类型将类型进行混合
17、多态
不同对象的相同函数输出不同,多态常常用在继承关系上。
接口抽象类定义父类抽象方法,实现类去实现父类的方法。
二、Python进阶
1、闭包(内部函数)
概念:声明一个函数中的函数,叫闭包函数。
作用:
- 避免使用全局变量
- 让外部访问函数内部变量
特点:内部函数引用了外部函数中的变量
在Java中拿不到private的字段使用get、set方法,而在Python中拿不到函数中的字段,可使用闭包函数获得字段并进行处理
#空参
def a():
name='lisi'
def b():
print(name)
return b
m= a();
m()
#有参,保留了内部函数变量一直保留,就不用设置全局变量,提高了安全性,但该方式也一直占着内存,容易溢出
def a(name):
def b(attribute):
nonlocal name
name=name+attribute
print(name)
return b
m= a('lisi');
m('age11')
m('gender1')
注意:内部函数要有返回值
可使用__closure__
判断是否为闭包函数。 在函数是闭包函数时,返回一个cell元素;不是闭包时,返回None。
2、装饰器
在不修改原函数基础上增加函数功能,类似Spring中AOP(切面编程)
def f():
print("程序执行")
def f1(func):
def f2():
print('before')
func()
print('after')
return f2
ff=f1(f)
ff()
在程序执行前输出before,执行后输出after,语法糖写法如下:
def f1(func):
def f2():
print('before')
func()
print('after')
return f2
@f1
def f():
print("程序执行")
f()
3、多线程
使用threading建立线程
import threading
import time
def t1():
while(True):
print('线程1')
time.sleep(1)
def t2():
while(True):
print('线程2')
time.sleep(1)
if __name__ == '__main__':
threading.Thread(target=t1).start()
threading.Thread(target=t2).start()
threading的初始化方法
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, *, daemon=None):
group:保留
target:执行的目标任务
args:目标任务元组传参
kwargs:目标任务字典传参
name:线程名
import threading
import time
def t1(parameter1):
while(True):
print('线程1'+str(parameter1))
time.sleep(1)
def t2(parameter2):
while(True):
print('线程2'+str(parameter2))
time.sleep(1)
if __name__ == '__main__':
# 加了,才是元组
threading.Thread(target=t1,args=('1111',),name='t1').start()
threading.Thread(target=t2,kwargs={'parameter2':'222'},name='t2').start()
4、网络编程
使用socket完成服务端与客户端通信
服务端:
import socket
server = socket.socket()
server.bind(("localhost",8088))
server.listen(5)
#accept为阻塞方法
conn,add=server.accept()
print(f"客户端地址{add}")
data = conn.recv(1024).decode("UTF-8")
print(f"客户端信息{data}")
s = input("服务器返回的信息").encode("UTF-8")
conn.send(s)
conn.close()
server.close()
客户端:
import socket
client = socket.socket()
client.connect(("localhost",8088))
s = input("客户端消息").encode("UTF-8")
client.send(s)
recv = client.recv(1024).decode("UTF-8")
print(f"服务器返回的信息{recv}")
client.close()
客户端:
import socket
client = socket.socket()
client.connect(("localhost",8088))
s = input("客户端消息").encode("UTF-8")
client.send(s)
recv = client.recv(1024).decode("UTF-8")
print(f"服务器返回的信息{recv}")
client.close()