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

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

Pthon基础

• python二级
• • python程序的基本语法
  • • python的格式框架
    • • 缩进
      • 注释
      • 分号
      • 空格
      
      
    • python的基本数据类型
    • • 数字类型
      • 字符串类型
      
      
    • 基本运算和表达式
    • • 命名
      • 变量
      • 表达式
      • 算术运算符
      • 比较运算符
      • 赋值运算符
      • 逻辑运算符
      
      
    • 基本输入输出函数
    • • 输入函数
      • 输出函数
      • format
      • eval函数
      
      
    
    
  • python的组合数据类型
  • • 列表
    • 元组
    • 字典
    • 集合
    
    
  • python程序的控制结构
  • • 基本赋值语句
    • • 简单赋值语句
      • 序列赋值语句
      
      
    • 顺序结构
    • 分支结构
    • • 单分支结构（if）
      • 二分支（if-eles）
      • 多分支结构（if-elif-else）
      
      
    • 循环结构
    • • while循环（无限循环）
      • for循环（遍历循环）
      
      
    • break和continue
    • • break
      • continue
      
      
    
    
  • 函数
  • • 函数的定义和使用
    • • 函数的定义
      • 函数的使用
      • 函数的返回值
      
      
    • 参数的传递方式
    • • 实参和形参
      • 位置参数
      • 默认值参数
      • 关键字参数
      • 可变参数
      • 组合参数
      
      
    • 变量作用域
    
    
  • 文件和数据维度
  • • 文件类型
    • • 文本文件
      • 二进制文件
      
      
    • 文件的打开和关闭
    • • 打开文件：open()
      • 关闭文件：close()
      
      
    • 文件的读写
    • • 文件的读取方法
      • 文件写入方法
      
      
    • 目录
    • 数据组织的维度
    • • 一维数据
      • 二维数据
      • 高维数据
      
      
    • 一维数据的处理
    • 二维数据的处理
    
    
  • python计算生态
  • • python计算生态
    • python内置函数
    • python内置标准库
    • • 库的引用
      • turtle库
      • time库
      • 第三方库的安装
      • pyinstaller库
      • jieba库
      • wordcloud库
      
      
    • 其他方向的第三方库
    • • 网络爬虫
      • 数据分析方向
      • 文本处理方向
      • 数据可视化方向
      • 用户图形界面方向
      • 机器学习方向
      • web开发方向
      • 游戏开发方向
      
      
    
    
  
  

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的基本数据类型

数字类型

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

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

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

复数

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


数据类型转换

字符串类型

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

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


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

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


字符串的复制：*

>>> str1 * 2
'liuliu'


转义符

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

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)


表达式

不做讲解

算术运算符

不做讲解

比较运算符

不做讲解

赋值运算符

不做讲解

逻辑运算符

基本输入输出函数

输入函数

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


输出函数

print格式化字符串

print("Hello World")


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" 是必须的


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 "

", line 1, in
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=',')


操作符

>>> _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()

关闭文件：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)



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)


其他方向的第三方库

网络爬虫

# 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