零基础学python（一）

1. 匿名函数

常规函数：

def fun(x, y):
    return x + y

匿名函数：

# lambda 空格后面是函数入参，冒号后面写函数体/函数逻辑
a = lambda x,y: x + y
print(a(2,3))

匿名函数/lambda函数的最大优点就是快速定义函数，使代码更精简。

使用lambda函数求列表所有数的平方和：

a = [1, 2, 3, 4, 5]
result = list(map(lambda x: x ** 2, a))
print(result)

from functools import reduce
result = reduce(lambda x, y: x + y, result, 0)
print(result)

上述过程中使用了map和reduce函数，类似于Java的流式操作，所不同的是Java中map和reduce是流对象的方法，而Python中map和reduce是内置函数，第二个参数是可迭代的集合。

还有filter操作：

a = [1, 2, 3, 4, 5]
result = list(filter(lambda x: x % 2 == 0, a))
print(result)

2. 变量作用域

根据变量作用域的划分，可以将变量分为全局变量和局部变量。对于整型全局变量，如果在函数中使用如下：

num1 = 10

def func():
    num1 = 20

print(num1)

此时打印仍是10，因为num1在函数中被认为是定义一个局部变量，跟第一行的全局变量没有关系，即在函数中修改全局变量num1未生效。如果想真正修改全局变量num1，需要引入global关键字：

num1 = 10

def func():
    global num1
    num1 = 20

print(num1)

但如果全局变量是列表，则可以在函数中修改成功，不用引入global变量，这是因为列表是可变数据类型的，而数字、字符串和元组是不可变的。

3. random库

random库用来生成随机数

import random

# 生成0-1之间的随机小数
print(random.random())

# 生成1-100的随机整数，包括1和100
print(random.randint(1,100))

使用原始方法获取列表a中的随机一个数：

print(a[random.randint(0, len(a) - 1)])

使用random的api 获取列表a中的随机一个数：

print(random.choice(a)) # a可以为一个字符串

随机打乱一个列表：

print(random.shuffle(a)) # a可以为一个字符串

4. 正则表达式

import re
result = re.match("hello", "hello world!")
print(result)

结果表示匹配到了，是索引0-5的位置，匹配到的内容是hello

\d 匹配单个数字：

result = re.match(r"\d", "123456")

\d+匹配多个数字：

result = re.match(r"\d+", "123456")

\w匹配字母数字以及下划线：

result = re.match(r"\w+", "a8*6")
print(result)

\s匹配任意空白字符：

result = re.match(r"\s", "      ")

$匹配结尾：

result = re.match(r"\s+$", "      ad")
print(result)

^匹配开头:

result = re.match(r"^\s+$", "      ")

.匹配任意字符:

result = re.match(r"^.+$", "waf-123")

[]表示可以匹配里面任意一个字符:

result = re.match(r"^[abcd]+$", "aaabbb")

[^] 表示可以不匹配里面任意一个字符

*表示匹配0个或多个，+表示匹配1个或多个:

result = re.match(r"^abcc+$", "abc")
print(result)

result = re.match(r"^abcc*$", "abc")
print(result)

{}表示精准匹配次数:

result = re.match(r"^abc{2,5}$", "abcccc")

|表示或：

result = re.match(r"^a|b|c$", "a")

5. 时间库

获取当前时间的时间戳

import time
t = time.time()
print(t)

获取结构化的时间，年份

t = time.localtime()
print(t)
print(t.tm_year)

将结构化时间转化为字符串

print(time.strftime("%Y %m %d %H:%M:%d", t))

6. socket库

socke库可以实现服务端和客户端的通信。首先创建服务端：

import socket

# 创建socket对象
sk = socket.socket()

# 绑定ip（本机）和端口号
sk.bind(("0.0.0.0", 8999))

# 设置监听，客户端个数为5个
sk.listen(5)

# 等待客户端连接
conn, addr = sk.accept()

print(conn)
print(addr)

然后创建客户端，使其连接服务端

import socket

# 创建socket对象
sk = socket.socket()

# 连接服务器
sk.connect(("127.0.0.1", 8999))

客户端连接服务端后， 在服务端打印日志如下：

客户端发送数据：

import socket

# 创建socket对象
sk = socket.socket()

# 连接服务器
sk.connect(("127.0.0.1", 8999))

while True:
    send_data = input("请输入你要发送的内容")
    
    sk.send(send_data.encode('utf8'))

    # 服务器响应的数据
    resp_data = sk.recv(1024)

    print(resp_data)

服务器接收数据：

import socket

# 创建socket对象
sk = socket.socket()

# 绑定ip（本机）和端口号
sk.bind(("0.0.0.0", 8999))

# 设置监听，客户端个数为5个
sk.listen(5)

# 等待客户端连接
conn, addr = sk.accept()

print(conn)
print(addr)

While True:
    accept_data = conn.recv(1024)

    print("收到客户端的数据： " + accept_data.decode('utf8'))

    send_data = "收到"
    conn.send(send_data.encode('utf8'))

7. 实例属性、类属性、实例方法、类方法

实例属性通过self.的方式来创建赋值或更新，比如在初始化函数中操作实例属性：

class Player:
    def __init__(self, name, age):
        self.name = name
        self.age = age

通过.__dict__可以查看实例的所有属性（字典的形式）：

tom = Player("tom", 24)
print(tom.__dict__)

类属性是所有实例共有的，定义在类中：

class Player:
    # 类属性
    numbers = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Player.numbers += 1

使用类属性需要使用类名.的方式：

print(Player.numbers)

实例方法是实例才能调用的方法，与普通的函数的区别在于：1. 在类中；2. 第一个参数是self；3. 调用时使用实例.的方式。

class Player:
    # 类属性
    numbers = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Player.numbers += 1

    def show(self):
        print(self.name + " " + self.age)
    
    def show_attr(self):
        for k,v in self.__dict__.items():
            print(k,v)

tom = Player("tom", 24)
tom.show()
tom.show_attr()

类方法是由@classmethod装饰器修饰的方法，第一个参数是cls，不通过实例来调用，通过类名.的方式来调用。

class Player:
    # 类属性
    numbers = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Player.numbers += 1

    def show(self):
        print(self.name + " " + self.age)
    
    @classmethod
    def show_numbers(cls):
        print(cls.numbers)        

tom = Player("tom", 24)
Player.show_numbers()

8. 静态方法

静态方法由@staticmethod装饰器来修饰，表示这个方法跟类与实例都不想关，第一个参数既不是cls，也不是self。 调用静态方法也是通过类名.的方式。

class Player:
    # 类属性
    numbers = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Player.numbers += 1

    def show(self):
        print(self.name + " " + self.age)
    
    @classmethod
    def show_numbers(cls):
        print(cls.numbers) 

    @staticmethod
    def is_valid(**kwargs):
        pass       

tom = Player("tom", 24)
Player.show_numbers()

9. 面向对象三大特性：继承、多态、封装

继承：子类继承父类，子类可以继承父类的属性，也可以有自己的一些独有属性，还可以调用或者覆写父类的方法。Python中继承父类使用"(Parent)"的方式：

class VIP(Player):
    def __init__(self, name, age, level):
        # 调用父类初始化函数
        super(name, age)
        self.level = level
        

tom = VIP("tom", 24)
print(type(tom))
print(isinstance(tom, Player))
print(isinstance(tom, VIP))

多态：同一个父类的不同子类，都拥有同名的方法，但是实现不一样，即多种形态。比如Python中的加号"+"，对于整数进行加号运算，就是求和，但是对于字符串进行加号运算，就是拼接了。

class Animal:
    def speak(self):
        print("    ")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

def speak(obj: Animal):
    obj.speak()


animal = Animal()
kitty = Cat()
puppy = Dog()

speak(animal)
speak(kitty)
speak(puppy)

封装：一个类、一个函数都算是封装，使用者只需要知道函数和类的功能，而无需关注其内部实现细节。Python中没有严格私有属性的概念，如果希望一个属性是私有的，可以在属性前加1个下划线表示受保护不能随便使用（只是一个约定），但只是希望如此，并非真正能保护，因为还是可以通过实例.属性名的方式访问到，如果想要真正保护属性，可以加上两个下划线：

class User:
    def __init__(self, name, age):
        self._name = name
        self.__age = age
        
tom = User("tom", 24)
print(tom._name) # 能访问
print(tom.__age) # 不能访问

函数也是类似的，通过前面加上双下划线来保护。但是可以通过其它方式来访问实例的私有属性和调用私有方法（加上_类名）：

print(tom._User__age) # 可以访问

使用dir内置函数查看对象的所有属性和方法（包括私有的）：

print(dir(tom))

既然私有属性不能随便访问，需要提供get/set方法来获取/修改私有属性：

class User:
    def __init__(self, name, age):
        self._name = name
        self.__age = age
        
    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age

tom = User("tom", 24)
tom.set_age(25)
print(tom.get_age())

使用装饰器@property和@setter来简化代码：

class User:
    def __init__(self, name, age):
        self._name = name
        self.__age = age
        
    # 将函数变为变量，不能再当做方法来调用
    @property
    def age(self):
        return self.__age

    # 变量修改器
    @age.setter
    def age(self, age):
        self.__age = age

tom = User("tom", 24)
tom.age = 25
print(tom.age)

这样做似乎与直接将age变为公有变量是一样的，都是调用tom.age来获取或者修改属性值，但是这样的好处是在setter方法中可以做一些必要的校验，如果直接将age设为公有变量，修改值时是直接修改没法校验的。

10. 魔法方法

Python中的魔发方法是以两个下划线开头的，在进行某些特殊的操作（比如运算符操作、转化为字符串等等）时，会调用到这些魔法方法。比如上述类的初始化魔法方法，就是在创建对象完之后会自动调用的方法。如果想将对象转换为字符串，可以重写__str__方法：

def __str__(self):
    return self.name + ": " + self.age

在调用str(对象)时，就会调用上面的__str__方法。

如果想对实例进行加法运算，可以重写__add__方法：

def __add__(self, other):
    return self.name + other.name

如果想对实例进行是否相等的判断，可以重写__eq__方法：

def __eq__(self, other):
    return self.name == other.name