Python入门

文章目录

Python入门

2.1 面向对象

创建类文件employee.py

class Employee:
    '所有员工的基类‘
    empCount = 0
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1
        def displayCount(self):
            print "Total Employee : ", Employee.empCount 
        def displayEmployee(self):
            print "Name : ",self.name, ", Salary: ", self.salary

init()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。

self：代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self代表类的实例，而非类

添加，删除，修改类的属性

e1.age = 22 # 添加属性del e1.age # 删除age属性

getattr(obj, name)：访问对象的属性

setattr(obj, name, value)：添加属性name值为value

hasattr(obj, name)：如果存在属性name就返回true

delattr(obj, name)：删除属性

类的继承

语法：

class ChildClass(ParentClass1[ , ParentClass2……]):  ……

注意：

在继承中基类的构造方法不会被自动调用，它需要在其派生类的构造中专门调用。
在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量

class Child(Parent):
    def __init__(self):
        print "调用子类构造方法"
        Parent.__init__(self)

运算符重载

#!/bin/python
# coding=utf-8
class Vector:    
 
   def __init__(self, a, b):
       self.a = a
       self.b = b
   
   def __str__(self):
       return "Vector ( %d, %d)" % (self.a, self.b)

   def __add__(self, other):
       return Vector(self.a + other.a, self.b + other.b)
   
v1 = Vector(6, 9)
v2 = Vector(2, 5)
print v1 + v2

属性与方法

私有属性：两个下划线开头，声明该属性为私有，不能在类外被使用或直接访问。

类方法：必须包含参数self，且为第一个参数。

私有方法：两个下划线开头，声明该方法为私有方法，不能在类外调用。

Python不允许实例化的类访问私有数据，但可以使用object._className__attrName访问属性。

单下划线，双下划线，头尾双下划线说明：

foo：定义的是特殊方法，一般是系统定义名字，类似__init__()之类的。

_foo：以单下划线开头的表示的是protected类型的变量，即保护类型。只能允许其本身与子类进行访问，不能用于from module import ＊

__foo：双下划线表示私有类型的变量，只能是允许这个类本身进行访问了。

2.2 正则表达式

re模块使python拥有全部的正则表达式功能。

2.2.1 re.match函数

re.match()尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话。match()就返回none。

re.match(pattern, string, flags=0)

参数说明：

pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等。

匹配成功re.match()方法返回一个匹配的对象，否则返回none。

group(num = 0)：匹配的整个表达式的字符串，group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

匹配对象方法	描述
group(num = 0)	匹配的整个表达式的字符串，group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
group()	返回一个包含所有小组字符串的元组

2.2.2 re.search函数

re.search()会在字符串内查找模式匹配，直到找到第一个匹配。

re.search(pattern, string, flags=0)

match和search的区别

match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回none，而search匹配整个字符串，直到找到一个匹配。

2.2.3 检索和替换

python的re模块提供了sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, max=0)

max是模式匹配后替换的最大次数，max必须是非负整数。缺省值是0表示替换所有的匹配。

2.3 操作mysql数据库

关于Python操作MySQL的增删查改操作，具体请看链接Python操作MySQL：https://blog.csdn.net/lmchhh/article/details/107602252

2.4 网络编程

python提供了两个级别访问的网络权限：

（1）低级别的网络服务支持基本的socket，它提供了标准的BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。

（2）高级别的网络服务模块SocketServer，它提供了服务器中心类，可以简化网络服务器的开发。

2.4.1 socket()函数

语法：

socket.socket([family [, type]]

family：套接字家族可以使AF_UNIX或者AF_INET

type：套接字类型可以根据是面向连接的还是非连接，分为SOCK_STREAM或SOCK_DGRAM

2.4.2 socket对象内建方法

服务器端套接字：

bind(host,port)：绑定地址到套接字

listen()：开始TCP监听

accept()：被动接受TCP客户端连接

客户端套接字：

connect()：主动初始化TCP服务器连接

connect_ex()：connect扩展版本，出错时返回错误码，而不是抛出异常。

公共套接字函数：

recv(bufsize)：接收TCP数据，bufsize指定要接收到最大数据量。

send()：发送TCP数据

示例：

Server

#!/usr/bin/python
# coding=utf-8
import socket

s = socket.socket() #创建socket对象
host = socket.gethostname() #获取本地主机名
port = 12345    #设置端口
s.bind((host, port))    #绑定端口

s.listen(5) #等待客户端连接

while True:
    c, addr = s.accept()
    print "连接地址：", addr
    c.send("欢迎访问......")
    c.close()

client:

#!/usr/bin/python
# coding=utf-8

import socket

s = socket.socket()
host = socket.gethostname()
port = 12345
s.connect((host, port))
print s.recv(1024)
s.close()

2.4.3 使用SMTP发送邮件

SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议，它是一组用于由源地址到目的地址传送邮件到规则，由它来控制信件到中转方式。

Python的smtplib提供了一种很方便的途径发送电子邮件。它对smtp协议进行类简单的封装。

语法：

smtpObj ＝ smtplib.SMTP( [host [ , port, hostname] ])

host：SMTP服务器主机，可以指定主机的IP地址或者域名，可选参数

port：一般情况下SMTP端口号为25

hostname：如果SMTP在本机上，只需要指定服务器地址为localhost即可。

Python的SMTP对象使用sendmail方法发送邮件。

语法：

SMTP.sendmail(from_addr, to_addr, msg)

from_addr：邮件发送者地址

to_addrs：字符串列表，邮件发送地址

msg：发送消息

具体操作可查看另一条比较详细的博客 https://blog.csdn.net/lmchhh/article/details/107586112

2.5 多线程

python中使用线程有两种方式：函数或者类来包装线程对象

函数式：

python调用thread模块中的start_new_thread()函数来产生新线程。

语法：

thread.start_new_thread(function, args[, kwargs])

function：线程函数

args：传递给线程函数的参数，它必须是一个tuple类型

kwargs：可选参数

示例：

# coding=utf-8

import thread
import time

def print_time(threadname, delay):
   count = 0
   while count < 5:
       time.sleep(delay)
       count += 1
       print "%s: %s " % (threadname, time.ctime(time.time()))

try:
   thread.start_new_thread(print_time, ("thread-1", 2,))
   thread.start_new_thread(print_time, ("thread-2", 4,))
except:
   print "Error: ....."

while 1:
   pass

类包装式：

使用Threading模块创建线程，直接从threading.Thread继承，然后重写__init__方法和run方法

示例：

# coding=utf-8

import threading
import time

exitFlag = 0

class myThread(threading.Thread):
    def __init__(self, threadID, name):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name

    def run(self):
        print "Starting " + self.name
        print_time(self.name, 5)
        print "Exiting " + self.name

def print_time(threadname, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print "%s: %s " % (threadname, time.ctime(time.time()))

thread1 = myThread(1, "thread-1")
thread2 = myThread(2, "thread-2")

thread1.start()
thread2.start()

print "EXIT"

执行结果：

Starting thread-1
Starting thread-2
 EXIT
thread-1: Tue Jul 21 10:36:22 2020
 thread-2: Tue Jul 21 10:36:22 2020
thread-2: Tue Jul 21 10:36:27 2020
 thread-1: Tue Jul 21 10:36:27 2020
thread-2: Tue Jul 21 10:36:32 2020
 thread-1: Tue Jul 21 10:36:32 2020
thread-1: Tue Jul 21 10:36:37 2020
 thread-2: Tue Jul 21 10:36:37 2020
thread-1: Tue Jul 21 10:36:42 2020
 Exiting thread-1
thread-2: Tue Jul 21 10:36:42 2020
Exiting thread-2

线程同步

使用Thread对象的Lock和RLock可以实现简单的线程同步，这两个对象都有acquire方法和release方法。

ef run(self):
        print "Starting " + self.name
        threadLock.acquire()
        print_time(self.name, 5)
        threadLock.release()
        print "Exiting " + self.name