Python基础（主要是计算机二级部分）

此文件专门为计算机二级做准备，以及一些其他进阶内容

python二级

python程序的基本语法

python的格式框架

缩进

规范：

• 一般缩进是4个空格（TAB）

• 一般一行代码的长度不超过80个字符，若超过则通过“\”反斜杠延续行

>>> for i in rnage(10):
>>>     print("Hello World")

注释

单行注释：#

# this is the comment for single-line

多行注释：# || “”” “”

# the first
# this is the comment for multi-line
# Hello World
# everyone

"""
the secondly
this is the comment for multi-line
Hello World
everyone
"""

分号

位置：一行的末尾加分号（不建议）

空格

位置：运算符两边（不强制加）

python的基本数据类型

数字类型

整数（受制于内存的大小）

类型	引导前缀	组成
二进制	0b	0 1
八进制	0o	0 1 2 3 4 5 6 7
十进制		0 1 2 3 4 5 6 7 8 9
十六进制	0x	0 1 2 3 4 5 6 7 8 9 A B C D E F

浮点数：-10**308~10**308

​ 表示方法：十进制和科学计数法

复数

>>> # 复试格式
>>> a + bj
>>> # 实部
>>> (a + bj).real
a
>>> # 虚部
>>> (a + bj).imag
b

数据类型转换

函数	描述
int（x）	将x转换成整数
float（x）	将x转换成一个浮点数
complex（x）	将x转换成一个复数，实部为x，虚部为0
complex（x，y）	将x和y转换成一个复数，实部为x，虚部为y

字符串类型

字符串的组成：单引号或双引号作用相同

>>> str = 'str'
>>> str2 = "str"

字符串的连接：用‘+’连接

>>> str1 = 'liu'
>>> str2 = 'hao'
>>> str3 = str1 + str2
>>> str3
'liuhao'

字符串的复制：*

>>> str1 * 2
'liuliu'

转义符

转义字符	含义
\n	换行
\t	横向制表符
\v	纵向制表符
\r	回车符
\f	换页符
\0	空值
’	单引号
"	双引号
\	\
\a	响铃
\b	退格

一些字符串中包含反斜杠（\），表示特定的含义，不需要转义字符生效

string = "D:\nothing"		# 此时容易把\n看成换行符
# 此时就要用r或R夹在字符串的前面
string = r"D:\nothing"

字符串的切片

str = "abcd"
s = str[1:2]

字符串相关函数和方法

# len:表示字符串长度
>>> str = "Hello World"
>>> len(str)
11

# ord:将该字符转换成对应的ASCII编码
>>> a = "a"
>>> ord(a)
97
"""
48~57:0~9
65~90:A~Z
97~122:a~z
"""

# chr:与ord相反

# title方法将每个单词首字母大写
>>> b = "hello world"
>>> b.title()
'Hello World'

# upper和lower:将字符串字符大写和小写
>>> b.upper()
'HELLO WORLD'
>>> b.lower()
'hello world'

# rstrip删除字符串末尾空白字符
>>> c = "python   "
>>> c.rstrip()
'python'

# lstrip删除字符串开头空白字符

# strip删除字符串首尾空白字符

基本运算和表达式

命名

规则：

• 首字符不能是数字
• 不能和保留字同字
• 不能有空格

变量

删除变量：del

del a

查看变量内存地址：id

id(a)

表达式

不做讲解

算术运算符

不做讲解

比较运算符

不做讲解

赋值运算符

不做讲解

逻辑运算符

运算符	描述
and	与
or	或
not	非

基本输入输出函数

输入函数

str = input("please input your name: ")

输出函数

print格式化字符串

print("Hello World")

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

format

在此介绍一个常用的输出函数format

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

设置参数

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

eval函数

作用：去掉字符串最外侧的引号

>>> a = eval('3' + '5')
>>> a
35

python的组合数据类型

列表

定义：有序，可以包含任意数据类型

创建列表

_mylist = []

向列表添加元素

# 在列表末尾添加元素
_mylist.append('a')

# 在指定位置添加元素
_mylist.insert('a', 3)

从列表中获取元素

_mylist[0]

从列表中删除元素

# insert
_mylist.remove('a')

# pop
_mylist.pop()
# 删除指定的元素
_mylist.pop(index)

其他方法

# count():某个元素在列表中出现的次数
>>> _list_count = [1, 3, 3, 6]
>>> _list_count.count(3)
2

# extend():扩展列表
>>> _list_a = [1, 2, 4]
>>> _list_b = ['a', 'b']
>>> _list_a.extend(_list_b)
>>> _list_a
[1, 2, 4, 'a', 'b']

# index:返回列表中第一次出现x元素的索引
>>> _list_count.index(3)
1

# reverse():反转列表
>>> _list_a.reverse()
>>> _list_a
['b', 'a', 4, 2, 1]

# sort排序
>>> _list_sort = [5, 3, 2, 8, 7]
>>> _list_sort.sort()
>>> _list_sort
[2, 3, 5, 7, 8]

# clear():清空列表
>>> _list_sort.clear()
>>> _list_sort
[]

列表切片

元组

元组和列表极其相似，不同在于元组元素不可修改

创建元素

a = (1, 2, 4)

更新，删除元素

>>> s = (1, 2, 4)
>>> f = (4, 6, 8)
>>> s + f
(1, 2, 4, 4, 6, 8)
>>> del s
>>> s
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s
NameError: name 's' is not defined

元组的内置函数

# len
# min
# max
# tuple:将列表转换成元素
>>> l = [1, 2, 4]
>>> tuple(l)
(1, 2, 4)

字典

由键值构成的无序集合

创建字典

# 直接创建
dic = {1: 'A', 2: 'B'}

# 通过元组创建
dict(('A', 1), ('B', 2))

访问字典的键和值

>>> _dict['A']
1

更新字典

>>> _dict = { 'A':  1, 'B': 2, 'C': 3 }
>>> _dict['A'] = 3
>>> _dict
{'A': 3, 'B': 2, 'C': 3}
>>> _dict['D'] = 1
>>> _dict
{'A': 3, 'B': 2, 'C': 3, 'D': 1}

删除键值对

>>> del _dict['D']
>>> _dict
{'A': 3, 'B': 2, 'C': 3}

字典的操作方法

# clear():清空字典内容
>>> _dict.clear()
>>> _dict
{}

# copy():返回一个新的新字典，不是副本
>>> _new_dict = _dict.copy()
>>> _new_dict
{'A': 3, 'B': 2, 'C': 3}
>>> id(_dict)
2101405099584
>>> id(_new_dict)
2101405093248

# get():返回指定键的值，不存在返回默认值
>>> _dict.get('C')
3

# keys():返回字典的所有键
>>> _dict.keys()
dict_keys(['A', 'B', 'C'])

# update():把字典的键值更新到另一个字典
>>> _update_dict = {'D': 6}
>>> _dict.update(_update_dict)
>>> _dict
{'A': 3, 'B': 2, 'C': 3, 'D': 6}

# values():以列表形式返回字典的所有值
>>> _dict.values()
dict_values([3, 2, 3])

# items():返回字典中的所有键值对
>>> _dict.items()
dict_items([('A', 3), ('B', 2), ('C', 3)])

集合

集合存储的元素是无序且不能重复的，不能排序

创建集合

_set = {1, 2, 4}

_set = set([2, 3, 5])

访问集合

for i in _set:
    print(i, end=',')

操作符

操作符及运算	描述
S-T	返回新的集合，包含在S中但不在T 中的元素
S&T（交集）	返回新的集合，同时包含在S和T 中的元素
S^T（交集的反集）	返回新的集合，包含在S和T 中的非共同元素
S|T（并集）	返回新的集合，包含在S和T 中的所有元素

>>> _set1 = {2, 3, 5}
>>> _set2 = {4, 6, 2}
>>> _set1-_set2
{3, 5}
>>> _set1&_set2
{2}
>>> _set1^_set2
{3, 4, 5, 6}
>>> _set1 | _set2
{2, 3, 4, 5, 6}

使用方法

# b.issubset(a):判断b是不是a的子集

# b.issuperset(a):判断b是不是a的超集

# s.union(t):s和t的并集

# s.intersection(t):s和t的交集

# s.difference(t):元素属于s不属于t

# s.symmertric_difference(t):不重复元素

# s.copy():浅复制

python程序的控制结构

基本赋值语句

简单赋值语句

a = 1

序列赋值语句

score1, score2 = 1, 2

顺序结构

分支结构

单分支结构（if）

二分支（if-eles）

多分支结构（if-elif-else）

循环结构

while循环（无限循环）

for循环（遍历循环）

break和continue

break

​ 终止循环语句

continue

​ 中断本次循环

函数

函数的定义和使用

函数的定义

# 格式
# def function(argument):
#     return none
def add(x, y):
    s = x + y
    return s

函数的使用

print(add(1, 2))

函数的返回值

s = add(0, 2)

参数的传递方式

实参和形参

形参：在函数定义时的参数，不是实际的变量

实参：函数调用时传入的参数

位置参数

调用函数时实参的数量和顺序必须和函数声明保持一致

默认值参数

def people(name, age = 12):
    print("Hello World")
    
    
def main():
    people("Rose")

    
if __name__ == "__main__":
    main()

关键字参数

def test(a, b, c):
	print("Hello World")

    
def main():
    people(a = 1, b = 2, c = 3)

    
if __name__ == "__main__":
    main()

可变参数

# *param:接收多个位置参数收集的实参形参一个元组
def func(arg, *param):
    print(param)


def main():
    func("LiuHao", 1, 2, 3)


if __name__ == "__main__":
    main()
    
# **param:接收多个位置参数收集的实参形参一个字典
def func(arg, **param):
    print(param)


def main():
    _dict = {'A': 1, 'B': 2, 'C': 3}
    func("LiuHao", **_dict)


if __name__ == "__main__":
    main()

组合参数

def func(arg, *param1, **param2):
    print(param1)
    print(param2)


def main():
    func("LiuHao", 'A', 'B', x = 1, y = 2)


if __name__ == "__main__":
    main()

变量作用域

不做概述

# global关键字:把变量全局变量
def func():
    a = 1
    global a
    return 1

文件和数据维度

文件类型

文本文件

由若干文本和组成，以换行符‘\n’结尾，扩展名为txt，ini，log

二进制文件

图像文件，音频文件，视频文件，可执行文件，各种数据库文件，各类office文件等，以字节存储

文件的打开和关闭

打开文件：open()

打开方式	功能
r	以只读方式打开，文件必须存在，不存在异常
w	以只写方式打开，存在则打开 ，不存在则创建
x	以写方式创建文件，不存在创建，存在异常
a	打开一个文件追加，文件存在，新内容写在已有内容后，不存在则创建
b	二进制方式打开
t	文本文件打开，默认值
+	与以上打开方式一起使用

关闭文件：close()

文件的读写

文件的读取方法

read：读取所有内容，如果指针已在文件末尾，则返回空字符串(“”)

>>> f = open("E:\py.txt", 'r')
>>> f.read()
'Hello World'

readline：读取一行内容，若是空行，返回“\n”

>>> f = open("E:\py.txt", 'r')
>>> f.readline()
'Hello World'

readlines：读取所有行，返回一个每行为元素的列表

>>> f = open("E:\py.txt", 'r')
>>> f.readlines()
['Hello World\n', 'Hello python']

seek：定位文件的读写位置

# seek(<偏移位置>[, 起始位置])
# 起始位置：0:文件开头；1:当前位置；2:文件末尾

文件写入方法

write：写入文件，如需换行，加上换行符

writeline：将一个元素为字符串的序列（如列表）整个写入文件

目录

OS模块

# remove:删除文件

# rename:重命名文件
>>> os.rename("test.py", "testpy.py")

# mkdir:在当前目录创建新的目录
>>> os.mkdir("testpy")

# chdir:设置当前目录

# getcwd:显示当前工作路径
>>> import os
>>> os.getcwd()
'C:\\Users\\ASUS\\Desktop'

# rmdir:删除目录
>>> os.rmdir("testpy")

# listdir:返回当前目录下的文件和子目录
>>> os.listdir()
...

数据组织的维度

一维数据

任何可以以序列或集合表示的内容都为一维数据

二维数据

表格数据，由关联关系数据构成，采用二维表格方式组织，对应数学中的矩阵

高维数据

由键值对类型的数据构成，采用对象方式组织，可以嵌套

一维数据的处理

一维数据的表示

lis = ['a', 'b', 'c']

一般是用逗号分开，存储到csv文件格式中

一维数据的处理

f = open('xxx.csv', 'r')
ls = f.read().strip()		# strip去除换行符
item = ls.split(',')		# 以#为间隔打开
f.close()

二维数据的处理

二维数据的表示

lis = [
    ['a', 'b', 'c'],
	['d', 'e', 'f']
]

二维数据的存储

csv存储

二维数据的处理

f = open('xxx.csv', 'r')
ls = []
for line in f:
    ls.append(line.strip('\n').split(','))
f.close()
print(ls)

python计算生态

python计算生态

http://pypi.python.org/pypi

python内置函数

# abs(x):求x的绝对值，如果是复数，返回他的模
>>> abs(3 + 4j)
5.0

# all(x):组合类型变量x中所有元素均为真时返回true，否则返回false；非空返回true
>>> _list = [1, 2, 3]
>>> all(_list)
True

#any:组合类型变量x中有一个元素均为真时返回true，否则返回false；非空返回true
>>> any(_list)
True

# ascii(object):返回一个字符串对象，如果参数中有非ascii字符则用\u,\v,\v替代
>>> ascii("a")
"'a'"
>>> ascii("你好啊")
"'\\u4f60\\u597d\\u554a'"

# bin:把整数x转换成等值的二进制字符串
>>> bin(10)
'0b1010'

# bool(x):将x转换成布尔型

# bytearray(x):返回一个新字节数组且元素可变，每个元素的值的范围是[0, 256)，当x是一个字符串，必须给出一种编码方式，以便转化成合适的字节保存
>>> a
bytearray(b'\xe4\xb8\xad\xe5\x9b\xbd')

# bytes(x):与bytearray类似，差别是返回的字节数组不可修改
>>> bytes(2)
b'\x00\x00'

# chr(x):返回Unicode为x的字符
>>> chr(48)
'0'

# complex(r, i)

# dict()

# divmod(a, b):返回a和b的商和余数
>>> divmod(20, 3)
(6, 2)

# range(a, b, s):输出[a, b)以补偿s产生的一个序列
>>> for i in range(1, 12, 2):
	print(i)
1
3
5
7
9
11

# set()

# round(x):四舍五入计算n
>>> round(12.3)
12
>>> round(12.8)
13

# exec(s):计算字符串s作为python语句的值
>>> exec('a = 12 + 5')
>>> a
17

# max():返回参数的最大值
>>> max(1, 2, 4)
4

# min():返回参数的最小值

# sum():对组合数据类型求各元素的和

# type():返回变量x的数据类型
>>> a = 1
>>> type(a)
<class 'int'>

python内置标准库

库的引用

# 导入一个库
import library
# 导入库中的某个方法
from library import method
# 导入库中所有方法
from library import *

turtle库

窗口函数

# setup(width, heigth, startx, starty):画布大小以及画布窗口宽高，窗口在品目的水平其实位置和垂直位置

画笔状态函数

# penup():提起画笔，不再绘制图形

# pendown():放下画笔，开始画

# pensize(width):画笔的宽度

# pencolor(color):画笔的颜色

# color():设置画笔和填充颜色

# begin_fill():在需要填充图形前使用

# end_fill():在填充图形后用

# filling():返回填充的状态，True为填充，False相反

# clear():清空当前窗口,但不改变画笔位置

# reset():清空当前窗口，回到默认值

# screensize():设置画笔的宽和高背景颜色

# hideturtle():隐藏画笔的turtle形状

# showturtle():显示画笔的turtle形状

# isviable():如果turtle可见，返回True

# write():输出中文标签

画笔运动函数

# forward(distance):把画笔向当前方向前进distance距离

# backward(distance):把画笔向当前方向后退distance距离

# right(angle):向右旋转angle角度

# left(angle):向左旋转angle角度

# goto(x, y):移动到坐标(x, y)处

# seth(to_angle):设置画笔当前朝向为to_angle角度，是绝对方向角度值

# home():设置当前画笔位置为原点，向右为正

# circle(radius, extend = None):根据半径radius绘制角度为extend的图形，当没有extend时，绘制整个图形

random库

# random:产生随机数
>>> import random
>>> random.random()
0.39852954665967555

# seed(a=None):初始化随机种子，默认值为当前系统时间，只要种子相同，每次生成的随机数字也相同
>>> from random import*
>>> seed(345)
>>> randint(1, 9)
5

# randint(a, b):随机生成一个[a, b]之间的整数

# uniform(a, b):随机生成一个[a, b]之间的小数
>>> uniform(1, 6)
1.028867913953381

# randrange(start, stop[, step]):生成一个(start, stop)之间以step为补偿的随机整数
>>> randrange(1, 90, 3)
40

# getrandbits(x):生成一个k比特长度的随机整数
>>> getrandbits(5)
3

# choice(seq):从序列类型中随机返回一个元素
>>> _list = [1, 4, 3, 2]
>>> choice(_list)
4

# shuffle(seq):把序列中的元素随机排列，返回打乱后的序列
>>> shuffle(_list)
>>> _list
[4, 1, 2, 3]

# sample(pop, k):从pop类型中随机选取k个元素，以列表形式访问
>>> _list_sample = [1, 4, 6, 7, 32, 4, 8]
>>> sample(_list_sample)
[6, 7, 8]

time库

基于1970年01月01日00分00秒其到现在的总秒数

时间处理

# time():获取当前时间戳
>>> time.time()
1616653849.0040529

# gmtime(secs):获取当前时间戳对于的struct_time对象
>>> time.gmtime(1616653849.0040529)
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=25, tm_hour=6, tm_min=30, tm_sec=49, tm_wday=3, tm_yday=84, tm_isdst=0)

# ctime(secs):获取的世界戳被内部调用location()函数输出当地时间
>>> time.ctime(1616653849.0040529)
'Thu Mar 25 14:30:49 2021'

时间格式化函数

# mktime:将struct_time转化成时间戳
>>> localtime()
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=25, tm_hour=14, tm_min=33, tm_sec=57, tm_wday=3, tm_yday=84, tm_isdst=0)
>>> mktime(localtime())
1616654052.0

# strftime():将struct_time转化成标准格式
>>> strftime("%Y-%m-%d %H:%M:%S", localtime())
'2021-03-25 14:36:53'

# strptime():与strftime相反

python第三方库

第三方库的安装

# pip安装
pip install 库名

# 自定义安装

#文件安装

pyinstaller库

pyinstaller -F demo.py

jieba库

# lcut(s)：返回一个列表类型
>>> import jieba
>>> jieba.lcut("你好啊，好久不见了")
Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\ASUS\AppData\Local\Temp\jieba.cache
Loading model cost 2.123 seconds.
Prefix dict has been built successfully.
['你好', '啊', '，', '好久不见', '了']

# lcut(s, cut_all=True):全模式，返回一个列表类型
>>> jieba.lcut("你好啊，好久不见了", cut_all=True)
['你好', '啊', '，', '好久', '好久不见', '不见', '了']

# lcut_for_search(s):搜索引擎模式，返回一个列表类型(会出现分词冗余)
>>> jieba.lcut_for_search("你好啊，好久不见了")
['你好', '啊', '，', '好久', '不见', '好久不见', '了']

# add_word(w):向分词自动中添加新词w
>>> jieba.add_word("你好")
>>> jieba.lcut("你好啊，好久不见了")
['你好', '啊', '，', '好久不见', '了']

wordcloud库

预处理：把所有文本进行分词处理，然后用空格拼接，最后调用该对象

words = jieba.lcut(txt)
newtxt = ''.join(words);
wordcloud = wordcloud(font_path='xxx').generate(newtxt)

参数	描述
font_path	字体文件的完整路径
width	生成图片宽度，默认400
heigth	生成图片长度，默认400
mask	词云形状，默认方形图
min_font_size	最小字体，默认4号
max_font_size	最大字体，跟随高度变化
font_step	字体步进间隔，默认1
stopwords	被排除词列表，排除的词不在词云中显示
background_color	图片背景颜色，默认为黑色
max_words	词云图中最大次数，默认200

其他方向的第三方库

网络爬虫

# requests

# scrapy

# pyspider

数据分析方向

# numpy

# pandas

# sicpy

文本处理方向

# pdfminer

# python-docx

# beautifulsoup4

数据可视化方向

# matplotlib

# seaborn

# mayavi

用户图形界面方向

# pyqt5

# wxpython

# pygtk

机器学习方向

# scikit-learn

# tensorflow

# mxnet

web开发方向

# Django

# pyramid

# flask

游戏开发方向

# pygame

# panda3d

# cocos2d