Python编程拾遗

渐变-重构

已于 2022-08-17 18:47:44 修改

阅读量764

点赞数

分类专栏： python学习文章标签： python numpy 开发语言

于 2022-08-17 18:47:20 首次发布

本文链接：https://blog.youkuaiyun.com/hscing/article/details/126392240

版权

python学习专栏收录该内容

9 篇文章

订阅专栏

Python编程拾遗

Python基础

Ctrl + Enter快捷键：在下方新建行,但不移动光标
Shift + Enter 快捷键：在下方新建并移到新行行首
Ctrl + / 快捷键：注释（取消注释）选择的行
Ctrl + D 快捷键：对光标所在行的代码进行复制
Pycharm就是IDE中的“瑞士军刀”。可以自动补全变量和函数，提示语法错误和潜在的问题，并且严格按照PEP8纠正编码习惯，同时也有内置的交互式解释器。

组合数据类型与字符串

#列表元素读取
a_list= ['math','hello',2017,2.5,[0.5],3]
a_list[::-1] #反转列表
a_list[1::-1]
a_list[-3::-1]
a_list[:-3:-1]

列表推导式 [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

函数

优点
- 程序结构清晰，可读性好
- 减少重复编码的工作量
- 可多人共同编制一个大程序，缩短程序设计周期，提高程序设计和调试的效率。
匿名函数
- lambda [参数列表]：表达式
高阶函数是在Python中一个非常有用的功能函数。一个函数可以用来接收另一个函数作为参数，这样的函数叫作高阶函数。
- map( )函数接收一个函数和可迭代对象，并通过把函数依次作用与后者，得到一个迭代器并返回。
```
def format_name(s):
    return s.capitalize()
return = map(format_name,['adam','LISA','barT'])
print(list(result))
```
- filter( )函数接收一个函数和可迭代对象，并通过函数依次作用后者上，但是只有函数返回为真时才会保留
```
a = [4,5,6,7]
b = filter(lambda x:x%2==0,a)
print(list(b))
```
- reduce( )函数把结果继续和可迭代对象的下一个元素做累积运算
```
from functools import reduce
def f(x,y):
    return x + y
result = reduce(f, [1,3,5,7,9])
print(result)
```

面向对象程序设计

对象
- 面向对象程序设计思想可以将一组数据和这组数据有关操作组装在一起，形成一个实体，这个实体就是对象(object).
类
- 具有相同或相似性质的对象的抽象就是类(class)。因此，对象的抽象是类，类的具体化就是对象。
封装
- 将数据和操作捆绑在一起，定义一个新类的过程就是封装。
继承
- 继承是类之间的关系，在这种关系中，一个类共享了一个或多个其他类定义的结构和行为。
方法
- 方法也称为成员函数，是指对象上的操作，作为类声明的一部分来定义。方法定义了对一个对象可以执行的操作。

构造函数

构造函数是一种成员函数，用来在创建对象时初始化对象。

拥有一个固定的名称，即_init_。当创建类的对象实例时，系统会自动调用构造函数，通过构造函数对类进行初始化操作

class UserInfo:
    def __init__(self,name,pwd):
        self.username = name
        self.__pwd = pwd
    def output(self):
        print("用户：" + self.username + "\n密码：" + self.__pwd)
        
        
u = UserInfo("admin","123456")
u.output()

析构函数
- 析构函数与构造函数相反，当对象脱离其作用域时，系统自动执行析构函数。析构函数往往用来做“清理善后”的工作。
- 拥有一个固定名称，即_del_。通常在解析函数中释放所占用的资源。使用del语句可以删除一个对象，释放它所占用的资源。
```
class MyString:
    def __init__(self):
        self.str = "MyString"
    def __del__(self):
        print("byebye~")
    def output(self):
        print(self.str)
s = MyString()
s.output()
del s
```

静态变量

Python不需要显式定义静态变量，任何公有变量都可以作为静态变量使用。访问静态变量的方法：类名.变量名

虽然也可以通过对象名访问静态变量，但是同一个变量，通过类名访问与通过对象名访问的实例不同，而且不互相干扰。

class Users:
    online_count = 0

    # 构造函数,创建对象时Users.online_count加1
    def __init__(self):
        Users.online_count += 1

    # 解析函数,释放对象时User.online_count减1
    def __del__(self):
        Users.online_count -= 1


a = Users()
a.online_count += 1
print(a.online_count)
print(Users.online_count)

静态方法的使用
- 与静态变量相同，静态方法只属于定义它的类，而不属于任何一个具体的对象。
  - 静态方法无须传入self参数，因此在静态方法中无法访问实例变量。
  - 在静态方法中不可以直接访问类的静态变量，但可以通过类名访问静态变量
- 因为静态方法既无法访问实例变量，也不能直接访问类的静态变量，所以静态方法与定义它的类没有直接关系，而是起到了类似函数工具库的作用
```
class MyClass:
    var1 = 'String 1'

    @staticmethod
    def staticmd():
        print("我是静态方法")


MyClass.staticmd()
c = MyClass()
c.staticmd()
```

类方法

与静态方法一样，可以使用类名调用类方法
类方法需传入代表本类的cls参数
与静态方法一样，类成员方法也无法访问实例变量，但可以通过类名访问类的静态变量。

类方法有一个参数cls，代表定义类方法的类，可以通过cls访问类的静态变量

class MyClass:
    val1 = 'String 1'

    def __init__(self):
        self.val2 = 'Value 2'

    @classmethod
    def classmd(cls):
        print(cls.val1)


MyClass.classmd()
c = MyClass()
c.classmd()

类的继承和多态

类可以继承其他类的内容，包括成员变量和成员函数。而从同一个类中继承得到的子类也具有多态性，即相同函数名在不同子类中有不同的实现。

继承最大的好处是子类获得了父类的全部变量和方法的同时，有可以根据需要进行修改、拓展。

class people:

    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.__weight = weight

    def speak(self):
        print("%s 说: 我 %d岁." % (self.name, self.age))

    # 单继承示例如下:


class student(people):
    def __init__(self, name, age, weight, grade):
        # 调用父类的实例化方法
        people.__init__(self, name, age, weight)
        self.grade = grade

    # 重写父类的speak方法
    def speak(self):
        print("%s 说：我 %d 岁了, 我在读%d 年级" % (self.name, self.age, self.grade))


s = student('Tom', 10, 30, 3)
s.speak()

Python支持多父类继承机制，所以需要注意圆括号中基类的顺序，若是基类中有相同的方法名，并且在子类使用时未指定，Python会左到右搜索基类中是否包含该方法一旦查找到则直接调用，后面不再继续查找

继承的两种类型

class D:
    def show(self):
        print("I am D")

    pass


class C(D):
    pass


class B(C):
    pass


class G:
    pass


class F(G):
    pass


class E(F):
    def show(self):
        print("I am E")

    pass


class A(B, E):
    pass


a = A()
a.show()

运行结果是 I am D。左边具有深度优先权，当一条路走到底也没找到的时候，才换另一条路。

class H:
    def show(self):
        print("I am H")

    pass


class D(H):
    pass


class C(D):
    pass


class B(C):
    pass


class G(H):
    pass


class F(G):
    pass


class E(F):
    def show(self):
        print("I am E")

    pass


class A(B, E):
    pass


a = A()
a.show()

结果是I am H ,这中情形下，共同继承类要留到最后去找。

如果子类中有父类同名的成员，那么久会覆盖掉父类中的成员。想强制调用父类的成员呢？可以使用super( )函数

语法：super(子类名，self).方法名( )传入的是子类名和self，调用的是父类里的方法，按父类的方法需要传入参数。

class A:
    def __init__(self, name):
        self.name = name
        print("父类的__init__()方法被执行了!")
        
    def show(self):
        print("父类的show()方法被执行了！")
       

class B(A):
    def __init__(self,name,age):
        super(B, self).__init__(name)
        self.age = age
        
    def show(self):
        super(B,self).show()

        
obj = B("jack", 18)
obj.show()

多态

class Animal:
    def kind(self):
        print("I am animal")


class Dog(Animal):
    def kind(self):
        print("I am a dog")


class Cat(Animal):
    def kind(self):
        print(" I am a cat")


class Pig(Animal):
    def kind(self):
        print("I am a pig")


def show_kind(animal):
    animal.kind()


d = Dog()
c = Cat()
p = Pig()
show_kind(d)
show_kind(c)
show_kind(p)

运算符重载

标准算数运算符在默认情况下不能用于自定义类对象的实例对象，运算符重载就是让自定义的类生成的对象(实例)能够使用运算符进行操作。

class Mynumber:
    def __init__(self, v):
        self.data = v

    def __repr__(self):  # 返回实例对象的字符串表示形式
        return "Mynumber=(% d)" % self.data

    def __add__(self, other):
        v = self.data + other.data
        return Mynumber(v)

    def __sub__(self, other):
        v = self.data - other.data
        return Mynumber(v)


n1 = Mynumber(500)
n2 = Mynumber(200)
n3 = n1 + n2
print(n3)
n4 = n3 - n2
print(n4)

网页爬取

网页结构

网页一般由三个部分组成，分别是HTML(超文本标记语言)、CSS(层叠样式)和JavaScript(活动脚本语言)

HTML是整个网页的结果，是整个网站的框架。带有“<” “>”符号的都属于HTML的标签，并且标签都是成对出现的。
- <html>. .</html>:表示标记中间的元素是网页
- <body>. .</body>:表示用户可见的内容
- <div>. . </div>:表示框架
- <p>. .<\p>:表示段落
- <li>. .</li>:表示列表
- <img>. .<img>:表示图片
- <h1>. .</h1>:表示标题
- < a href= " ">. .</a>:表示超链接
CSS表示样式，

一个简单的HTML

<html>
    <head>
        <title>Python3网页爬取</title>
    </head>
    <body>
        <div>
            <p>Python爬虫 666</p>
        </div>
        <div>
            <ul>
                <li><a href = "http://c.biancheng.net">爬虫</a></li>
                <li>数据清洗</li>
            </ul>
        </div>
    </body>     
</html>

利用正则表达式爬取内容

正则表达式(regular expression)描述了一种字符串匹配的模式(pattern),可以用来检验一个串是否含有某种子串，将匹配的子串替换或者从某个串中取出符合某个条件的子串等

单字符匹配规则(略)
表示数量的规则(略)
表示边界的规则(略)
匹配分组的规则(略)

Python 网络编程

OSI参数模型的通信过程

在网络通信中，发送端自上而下地使用OSI参考模型，对应用程序要发送的信息进行逐层打包，直至在物理层将其发送到网络中；而接受端则自下而上地使用OSI参考模型，将收到物理数据逐层解析，最后将得到的数据传送给应用程序。但并非所有的通信网络都需要经过OSI模型的全部7层。

TCP/IP体系结构概述

TCP/IP是Internet的基础网络通信协议，它规范了网络上所有网络上所有网络设备之间数据往来的格式和传送方式。TCP和IP是两个独立的协议，它们负责网络中数据的传输。TCP位于OSI参考模型的传输层，而IP则位于网络层。TCP/IP和OSI参考模型之间的对应关系图如图所示。

Socket编程

Socket 翻译为套接字，它是TCP/IP网络环境下应用程序与底层通信驱动程序之间运行的开发接口，可以将应用程序与具体的TCP/IP隔离开，使得应用程序与底层驱动程序之间运行的开发接口，可以将应用程序与具体的TCP/IP隔离开，使得应用程序不需要了解TCP/IP的具体细节，就能够实现数据传输。

Socket开发接口位于应用层和传输层之间，可以选择TCP和UDP两种协议实现网络通信。Python的Socket编程通常可分为TCP和UDP编程两种。前者是带连接的可靠传输服务，每次通信都要握手，结束传输也要握手，数据会被检验，是使用最广的通用模式；后者是不带连接的传输服务，简单粗暴，不加控制和检查地直接将数据发送出去的方式，但是传输速度快，通常用于安全和可靠等级不高的业务场景，如下载文件

下面是面向连接的Socket通信是基于TCP的，网络中的两个进程以客户机/服务器模式进行通信。