一、Python基础-CSDN博客

本文链接：https://blog.csdn.net/wslzoooo/article/details/135308106

一、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()