Python3基础

Python3基础

1.常量和变量

  • 变量
    变量在程序中就是用一个变量名表示的，变量名是大小写英文、数字和_组合，且不能用==数字==开头。

  • 常量
    即不能变的变量，通常用==全部大写==的变量名表示常量

2.Python语言算术运算符

运算符 描述 例子
** 指数，执行对操作数的幂计算 a**b = 10^20(10的20次方)
// 整除，其结果是将商的小数点后的数舍去 9//2 = 4，而9.0//2.0 = 4.0

3.序列数据结构

  • 列表、元组和字符串

Python列表操作符

  • +用于组合列表，*用于重复列表。
Python表达式 描述 结果
[1,2,3] + [4,5,6] 组合 [1,2,3,4,5,6]
[‘Hi!’] * 4 重复 [‘Hi!’,’Hi!’,’Hi!’,’Hi!’]

4.元组

Python的元组(tuple)和列表类似，不同之处在于==元组==的元素==不能修改==，元组使用圆括号(),列表使用方括号[],元组的元素类型也可以不相同。

元组与列表的区别

  • 列表是==动态==数组，它们==可变==且可以重设长度（改变其内部元素的个数）。
  • 元组是==静态==数组，它们==不可变==，且其内部数据一旦创建便无法改变。
  • 元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。

5.字典

  • 字典的每个==键/值==对里面键和值用==冒号==分隔，键/值对==之间用逗号==分隔，整个字典包括在==花括号==中

例如：

1
d = {key1 : value1 , key2 : value2}

特性

  1. 字典值可以是任何Python对象，如字符串、数字、元组等。
  2. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会覆盖前面的值。

典方法和内置函数

函数 函数描述
dict1.get(key , default = None) 返回指定键的值，如果值不在字典中则返回default值

6.集合

集合(set)是一个==无序不重复==元素的序列。集合基本功能是进行==成员关系测试==和==删除重复元素==。

  • 字典可以使用花括号{}或者set()函数创建集合。注意，创建一个==空集合必须用set()==而不是{}，因为{}用来创建一个空字典。

7.Python控制语句

7.1.分支结构

  1. 单分支结构

    1
    2
    if <条件>：
    	<语句块>

  2. 二分支结构

    1
    2
    3
    4
    if<条件>： 
    	<语句块1>
    else: 
    	<语句块2>

  3. 多分支结构

    1
    2
    3
    4
    5
    6
    7
    if <条件1> :
    	<语句块1> 
    elif<条件2> :
    	<语句块2>
    ...... 
    else: 
    	<语句块N>

注意:

  • 该语句可以利用一系列条件表达式进行检查，并在某个表达式为真的情况下执行相应的代码。
  • 虽然该语句的备选动作较多，但是==有且只有一组==动作被执行。
  • 最后面的else语句没有进行条件判断，它实际处理的是跟前面所有条件都不匹配的情况下的情况，所以else语句==必须放在最后==。

7.2.循环结构

  1. while语句
  • 当判断条件1为true时执行循环语句。若此时判断条件2为true，执行break跳出while循环，若判断条件2一直为false，则执行while循环，一直到判断条件1为false。

例如：

1
2
3
4
5
6
count = 0
while(count <= 10):
	print("现在计数为:",count)
	count += 1 
	if(count \> 5): 
	break
  1. for语句&continue
  • 可以遍历任何一个序列的项目，比如一个列表、元祖、或者一个字符串

当遍历序列时，如果判断语句1为真，则执行continue语句，跳出当前循环，直接进入下一次循环。

例如：

1
2
3
4
for iteration\_var in sequence:    
	循环语句   
	if 判断语句1：    
	continue
  1. range()函数

例如，range(0,5)或range(5)生成的序列是从0开始到小于5的整数，不包括5==（左闭右开）==，实例如下：

1
2
3
4
5
list(range(5))

---

[0,1,2,3,4]

8.求最大数和最小数

1
2
print(min(list)) #输出最小数
print(max(list)) #输出最大数

9.Python函数与模块

9.1.函数的优点

  1. 代码重用
  2. 保持一致性，易维护
  3. 可扩展性强

9.2.Lambda表达式

  • 用于声明匿名函数，只可以包含一个表达式

语法：

1
lambda [arg1 [,arg2,.....argn]]:expression

冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式（只能为一个）。其实lambda返回值是一个函数的地址，也就是函数对象。

注意：

Python中函数是可以返回多个值的，如果返回多个值，会将多个值放在一个元组或者其他类型的集合中来返回。

1
2
3
4
5
6
7
8
9
def function():
	x = 2
	y = [3,4]
	return (x,y)
print (function)

---

(2,[3,4])

**若无 return ，将返回 None **

10.函数参数

10.1.函数形参和实参的区别

括号里面的变量称为形参，调用函数提供的值或者变量称为实参。

例如：

1
2
3
4
5
6
7
def add(a,b):	#这里a和b就是形参
	return a+b
	#下面是调用参数
add(1,2)	#这里1和2是实参
x = 2
y = 3
add(x,y)	#这里x和y是实参

10.2.函数参数的类型

  1. 默认参数

在定义函数时给形参赋予一个默认值，当调用函数时，如果没有给该参数赋新值，则会使用这个默认值。如果给参数赋予了新值，则会使用新值。

例如：

1
2
3
4
5
def info(name = 'Mark' , age = 22):
	print('%s今年%s岁' % (name , age))

info()	#这里输出默认值
info('Lily' , 24)	#默认参数已被覆盖，输出新值
  1. 关键字参数

关键字参数是以键值对的形式定义和调用的，清除了参数的顺序要求，在调用的时候不需要考虑参数的位置。

例如：

1
2
3
4
5
def info(name , age):
	print('%s今年%s岁' % (name , age))

info(name = 'Ken' , age = 23)	#输出：Ken今年23岁
#关键字参数，可以不考虑参数位置，即name和age可以交换位置
  1. 任意个数参数（可变参数）

可变参数分为可变位置参数和可变关键字参数。

  • 可变==位置==参数使用args，把一个或多个参数封装成一个元组，然后在元组里面进行迭代。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
def func(*args):
	print(type(args))	#type()函数用于返回对象的类型
	for i in args:
		print(i)

func(1,20,35)	#参数个数可变

---

1
20
35
  • 可变==关键字==参数使用**kwargs，把参数构成一个key-value键值对组成的字典。

例如：

1
2
3
4
5
6
7
8
9
10
11
def func(**kwargs):
	print(type(kwargs))
	for key , value in kwargs.items():
		print('key = {} , value = {}'.format(key , value))

func(name = 'Summer' , age = 20)	#参数个数可变

---

key = name , value = Summer
key = age , value = 20

11.变量的作用域

变量起作用的范围称为变量的作用域，一个变量在函数外部定义和函数内部定义，其作用域是不同的。

  1. 局部变量

在函数内部定义的变量，作用域也仅限于函数内部，出了函数便不能使用。

  1. 全局变量

和局部变量不同，全局变量的默认作用域是整个程序，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。

注意：

如果一个局部变量和一个全局变量重名，则局部变量会“屏蔽”全局变量，也就是局部变量起作用。

12.字符串函数

函数 描述
string.lstrip() 截掉string左边的空格
string.rstrip() 删除string字符串末尾的空格
string.strip() 删除string字符串首尾全部空格

13.文件的访问

值 描述
“r” 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
“w” 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
“a” 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

** 读取文本文件**

  1. read() 每次读取==整个文件==，它通常将读取到底文件内容放到一个==字符串变量==中，也就是说 read() 生成文件内容是一个==字符串类型==。
  2. readline()每只读取文件的==一行==，通常也是读取到的一行内容放到一个==字符串变量==中，返回==str类型==。
  3. readlines()每次按行读取==整个文件==内容，将读取到的内容放到一个==列表==中，返回==list类型==。

写入文本文件

  1. write()方法
    write()方法将==字符串参数==写入文件
  2. writelines()方法
    writelines()方法将==字符串序列==写入文件

注意：
write() & writelines()方法不能自动在字符串末尾添加换行符，需要自己添加==”\n“==。

14.文件的关闭

可使用try/finally语句 & with语句自动关闭文件

1
2
3
4
5
6
7
8
9
10
11
12
13
#try/finally语句
File = open('c:\\hello.txt','w')
try:
	File.write("Hello World")
finally:
	File.close()

---

#with自动关闭
with open('c:\\hello.txt') as f:
	s = f.read()
print(s)

raise()语句抛出异常

例如：

1
2
3
4
5
#当x小于0时，抛出异常并停止程序:
x = -1

if x < 0:
	raise Exception("x需要是大于等于0的数字")

15.目录操作

  • os.makedirs()函数创建新==多级==目录。
  • os.mkdir()函数创建新==一级==目录。

16.类和对象

  • self（约定俗成的一种习惯）

类的成员函数必须有一个参数self，而且位于参数列表的开头。self就代表类的实例（对象）自身，可以使用self引用类的属性和成员变量。在类的成员函数中访问实例属性时需要以self为前缀。

17.构造函数

解释：

在对象进行实例化的时候，系统==自动==调用的一个函数叫构造函数，通常此函数用来对实例化对象进行==初始化==。

__init__()方法是一个特殊的方法，在对象实例化时会被调用，__init__()方法的作用是初始化。

18.私有成员和公有成员

  • 在定义类的成员时，如果成员名以两个下划线“_ _”或更多下划线开头而不以两个或更多下划线结束则表示是私有成员。

访问方法：

==对象名._类名+私有成员==

19.SQLite数据库

  • Python自带一个==轻量级==的关系型数据库SQLite。
  • SQLite是非常小的、轻量级的、自给自足的，==无服务器==，所以不需要安装和管理。
  • SQLite3采用了==动态==的数据类型，会根据存入值自动判断。
  • SQLite使用==弱==数据类型，除了主键，对其它字段不指定类型是完全有效的。

20.TCP和UDP的区别

  • TCP 提供的是面向连接、可靠的字节流服务,并且有流量控制和拥塞控制功能。
  • UDP 提供的是无连接、不可靠的数据报传输,无流量控制和拥塞控制。

21.科学计算

主要工具：

经典例题

1.数据库操作

要求：

  1. 数据库表的创建。
  2. sql批量插入5条记录。
  3. 查询，带条件，select * from 表 where 条件。
  4. 删除数据，带条件。

Python SQLite数据库操作

实例代码1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import sqlite3
class Mysqlite(object):
    def __init__(self,dbpath):
        # 如果不存在则创建
        self.con = sqlite3.connect(dbpath)
        self.cur = self.con.cursor()

    def __del__(self):
        self.close()
    
    def execute_sqlite3(self,sql):
        # 命令处理
        sql = sql.lower()
        if 'insert' in sql or 'delete' in sql or  'update' in sql or  'create' in sql:
            self.cur.execute(sql)
            self.con.commit()
            print('done..')
            return 
        elif 'select' in sql :
            self.cur.execute(sql)
            data = self.cur.fetchall()
            print(data)
            return data

    def create_table(self,table_name,title):
        # 自定义创建表
        sql = "CREATE TABLE {}({})".format(table_name,title)
        self.execute_sqlite3(sql)

    def insert_value(self,table_name,value):
        # 插入自定义数据
        sql = "INSERT INTO {} values({})".format(table_name,value)
        self.execute_sqlite3(sql)

    def select_data(self,table_name):
        # 查询数据
        sql = "SELECT * FROM {}".format(table_name)
        self.execute_sqlite3(sql)

    def update_data(self,table_name,field,value,id):
        # 修改数据
        sql = "UPDATE {} set {} = '{}' where id = {}".format(table_name,field,value,id)
        self.execute_sqlite3(sql)
    
    def delete_data(self,table_name,id):
        # 删除数据
        sql = "DELETE FROM {} where id = {}".format(table_name,id)
        self.execute_sqlite3(sql)

    def close(self):
        # 关闭资源
        self.cur.close()
        self.con.close()

if __name__ == "__main__":
    sqlite = Mysqlite('test.db')
    table_name = 'foo'
    try:
        sqlite.create_table(table_name,'id integer primary key autoincrement, name varchar(128), info varchar(128)')
    except:
        print("{} created..")
    sqlite.insert_value(table_name,'NULL,\"apple\",\"broccoli\"')
    sqlite.select_data(table_name)
    sqlite.update_data(table_name,'name',"orange",1)
    sqlite.select_data(table_name)
    sqlite.delete_data(table_name,2)
    sqlite.select_data(table_name)

实例代码2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import sqlite3

def selectdb():
    try:
        con = sqlite3.connect("student.db")
        cur = con.cursor()
        cur.execute("select * from student")
        a=cur.fetchall()
        if len(a) > 0:
            print("--------------------------------")
            print("序号""\t\t""姓名""\t\t""年龄""\t\t")
            for i in range(len(a)):
                print(a[i][0], "  \t", a[i][1], " \t", a[i][2])
            print("--------------------------------")
        else:
            print("------信息表为空------")

        # print(cur.rowcount)
        con.commit()
    except Exception as ex:
        print(ex)
    finally:
        cur.close()
        con.close()

def deldb():
    try:
        con = sqlite3.connect("student.db")
        cur = con.cursor()
        cur.execute("delete from student where name=?", ("小奥",))
        cur.execute("select * from student")
        print("删除数据后：" )
        # print(cur.rowcount)
        con.commit()
        selectdb()
    except Exception as ex:
        print(ex)
    finally:
        cur.close()
        con.close()

def updatedb():
    try:
        con = sqlite3.connect("student.db")
        cur = con.cursor()
        cur.execute("update student set name=? where id=?", ("小仔", 6))
        cur.execute("select * from student")
        print("更新数据后：" )
        # print(cur.rowcount)
        con.commit()
        selectdb()
    except Exception as ex:
        print(ex)
    finally:
        cur.close()
        con.close()

def main():
    con = sqlite3.connect("student.db")
    cur = con.cursor()
    cur = con.execute("""create table if not exists student
                        (
                        id integer primary key autoincrement,
                        name varchar(40),
                        age varchar(30))""")
    student = [(1, "小明", '18'), (2, "小白", '18'), (3, "小奥", '19'), (4, '小火', '19'), (5, '小子', '17')]
    cur.executemany("insert into student(id,name,age) values (?,?,?)", student)
    print(cur.rowcount)
    cur.execute("insert into student(id,name,age) values (6,'小考','17')")
    print(cur.rowcount)
    con.commit()
    # cur.close()
    # con.close()
    selectdb()
    deldb()
    updatedb()
    
if __name__ == '__main__':
    main()

2.TCP&UDP

TCP文件下载简单实现

什么是下载？

  1. 首先客户端会问服务器，有没有xxx文件？服务器开始寻找，找到后答复客户端，然后客户端在本地新建一个文件，双方实时的发送和接收，待所有接收到的数据都写入到这个文件中，就完成了下载的操作。
  2. 所以下载需要两个部分。服务器的发送方和客户端的接收方。
  3. 这里不考虑复杂的情况，只实现最简单的逻辑。

客户端参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import socket

def main():

    # 创建socket
    tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 目的信息
    server_ip = '127.0.0.1'
    server_port = 8888

    # 链接服务器
    tcp_client_socket.connect((server_ip, server_port))

    # 输入需要下载的文件名
    file_name = input("请输入要下载的文件名：")

    # 发送文件下载请求
    tcp_client_socket.send(file_name.encode("utf-8"))

    # 接收对方发送过来的数据，最大接收1024个字节（1K）
    recv_data = tcp_client_socket.recv(1024)
    # 如果接收到数据再创建文件，否则不创建
    if recv_data:
        with open(file_name + "[接收]", "wb") as f:
            f.write(recv_data)
    # 关闭套接字
    tcp_client_socket.close()

if __name__ == "__main__":
main()

服务端参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import socket
def get_file_content(file_name):
    """获取文件的内容"""
    try:
        with open(file_name, "rb") as f:
            content = f.read()
        return content
    except:
        print("没有下载的文件:%s" % file_name)

host = '127.0.0.1'
port = 8888

def main():
    # 创建socket
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 本地信息
    address = ('', port)
    # 绑定本地信息
    tcp_server_socket.bind(address)
    # 将主动套接字变为被动套接字
    tcp_server_socket.listen(128)

    while True:
        # 等待客户端的链接，即为这个客户端发送文件
        client_socket, clientAddr = tcp_server_socket.accept()
        # 接收对方发送过来的数据
        recv_data = client_socket.recv(1024)  # 接收1024个字节
        file_name = recv_data.decode("utf-8")
        print("对方请求下载的文件名为:%s" % file_name)
        file_content = get_file_content(file_name)
        # 发送文件的数据给客户端
        # 因为获取打开文件时是以rb方式打开，所以file_content中的数据已经是二进制的格式，因此不需要encode编码
        if file_content:
            client_socket.send(file_content)
        # 关闭这个套接字
        client_socket.close()
    # 关闭监听套接字
    tcp_server_socket.close()

if __name__ == "__main__":
    main()

3.下标和

编写函数实现输入整型列表L,和一个整型参数goal,求列表L中所有满足两两之和为goal的元素的下标。

例如：输入一个整型列表L·=[1,3,5,7,9,2,-1],goal=8,而列表L中所有满足和为goal的元素为：
L[0]+L[3]=8
L[1]+L[2]=8
L[4]+L[6]=8
则输出为：((0,3),(1,2),(4,6))

1
2
3
4
5
6
7
8
9
10
11
12
13
L = [1,3,5,7,9,3,2,-1,3]
goal = 8

def TwoNumSum(L,goal):
	list1 = []
	for i in range(len(L)):
		for j in range(i+1,len(L)):
			if L[i] + L[j] == goal:
				list1.append((i,j))	
	return(tuple(list1))
	
a = TwoNumSum(L,goal)
print(a)

4.目录logs

在桌面新建目录logs,并完成以下操作：

  1. 在logs目录下新建11个文件，分别作为凌晨0点到早上10点的日志文件，文件命名规则为2021042000.txt~2021042010.txt,文件内容为长度为10的随机字符串。
  2. 将logs目录下所有以.txt结尾的后缀名都改为.log
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os  
import random  
import shutil  

logspath = "C:\\Users\\admin\\Desktop\\logs"  
s = "wfowiefnguow209384f389"  

if not os.path.exists(logspath):  
	os.mkdir(logspath)  
os.chdir(logspath)  

for i in range(2021042000, 2021042011):  
	filename = str(i) + '.txt'  
	content = ''.join(random.sample(s, 10))  
	with open(filename, 'w') as f:  
		f.write(content)  
  
for file in os.listdir(os.getcwd()):  
	newfile = file.split('.')[0] + '.log'  
	shutil.move(file, newfile)

5.升序排列

scores = [( ‘B’ , 89), ( ‘A’ , 16), ( ‘ C’ , 60), ( ‘D’ , 67)]
用sorted函数对上述列表元素按照成绩升序排列

1
2
3
scores = [('B', 89), ('A', 16), ('C', 60), ('D', 67)]
a = sorted(scores, key = lambda s: s[1])
print(a)

6.包含abc输出

已知下列一组字符串列表，完成以下需求：
L=[‘fwieng’,’weiabcfwie’,’ sdfaafaab’,asdfverabc’ ,’ ebeabrifje’ ,’ abcfwefwe’ ]
将所有包含’abc’的字符串输出，例如result=[‘weiabcfwie’,’asdfverabc’,’ abcfwefwe’ ]

1
2
3
4
5
6
7
8
result = [ ]
L=['fwieng', 'weiabcfwie','sdfaafaab', 'asdfverabc', 'ebeabrifje', 'abcfwefwe']

for s in L :
	if "abc" in s:
		result.append(s)
		
print(result)

7.汽车Car

建立一个汽车car类，包括：

属性：汽车颜色color、车身重量weight、速度speed。

构造函数：能初始化各个属性值（speed初始值设为50)。

方法：
speedup():将属性值 speed+10 并显示 speed 值；
speedCut():将属性值 speed-10 并显示 speed 值；
show():显示属性值color、weight、speed。

在主程序中创建实例并初始化各属性值，调用show方法、加速方法、减速方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Car:  
    def __init__(self , color='', weight=0, speed=0):  
        self.color = color  
        self.weight = weight  
        self.speed = speed  
    def speedUp(self):  
        self.speed += 10  
 print('车辆正在加速,当前speed值为：',self.speed)  
    def speedCut(self):  
        self.speed -= 10  
 print('车辆正在减速,当前speed值为：',self.speed)  
    def show(self):  
        print('车辆的颜色为:',self.color,'车辆的重量为:',self.weight,'车辆的速度为:',self.speed)  
  
if __name__ == '__main__':  
 c = Car('白色', 800, 50)  
 c.show()  
 c.speedUp()  
 c.speedCut()

8.数据库查询

前三行数据查询

cur.fetch==all==():返回结果集的剩余行（Row对象列表），无数据时，返回空List。

1
2
3
4
res = cur.fetchall()	
for line in res:
	print("id:{},price:{},name:{}".format(line[0],line[1],line[2]))
	line = cur.fetchone()

cur.fetch==many==():返回结果集的多行（Row对象列表），无数据时，返回空List。

1
2
3
4
res = cur.fetchmany(3)	
for line in res:
	print("id:{},price:{},name:{}".format(line[0],line[1],line[2]))
	line = cur.fetchone()

尾巴