python 居中对齐 * 遍历循环_python_study_note

2 Python语言基本语法元素

一、基本语法元素

程序的格式框架

if、elif、else、for、while、def、try、except均需添加英文冒号

缩进

强制可读性

4个空格 / 1个Tab(制表符)

注释

单行注释 ：以 # 开头

多行注释 ：每行注释前以 # 开头，或使用三个单引号 ''' 或者三个双引号 """ 将注释括起来

变量及命名

首字母不能是数字

中间不能有空格

大小写敏感

保留字

/

/

/

/

/

/

and

as

assert

break

class

continue

def

del

elif

else

except

finally

for

from

False

global

if

import

in

is

lambda

nonlocal

not

None

or

pass

raise

return

try

True

while

with

yield

数据类型

用来表达数据的含义，消除计算机对数据理解的二义性。

类型：整数、浮点数、复数、字符串、列表、字典

赋值语句

=

引用

全命名空间引用

# import

import turtle #引用功能库

turtle.down() #采用 .() 方式调用其具体功能

# 注意：后续调用库的具体功能时，必须写库名

具体函数引用

# from import

from turtle import up #引用turtle的up函数

up() #引用函数名后，采用 () 方式调用其具体功能

from turtle import setup, penup, fd, pendown

全函数引用

# from import *

from turtle import * #引用turtle所有函数

down() #全函数引用后，采用 () 方式调用其具体功能

# 后续不必写库名，直接写函数，否则会报错

别名引用

# from as

from turtle as tt

tt.up() #别名引用后，采用 .() 方式调用其具体功能

二、基本输入输出函数

1.input函数

# 变量 = input("提示性文字")

TempStr = input("请输入带有符号的温度值：")

# 无论用户在控制台输入什么内容，该函数都以字符串类型返回结果

2.eval函数

将输入的字符串转化为python语句，去掉参数最外侧引号并执行余下语句的函数。

功能：将字符串str当成有效的表达式来求值并返回计算结果。

TempStr = "102C" #用户输入“102C”

eval(TempStr[0,-1]) #经过该函数处理，输入的字符串将变成可进行数学运算的数值“102”

示例：eval函数可以实现list、dict、tuple与str之间的转化。

# 字符串转换成列表

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"

print(type(a))

print(a)

b = eval(a)

print(type(b))

print(b)

# 字符串转换成字典

a = "{1: 'a', 2: 'b'}"

print(type(a))

b = eval(a)

print(type(b))

print(b)

#字符串转换成元组

a = "([1,2], [3,4], [5,6], [7,8], (9,0))"

print(type(a))

b=eval(a)

print(type(b))

print(b)

3.print函数

单变量输出

print( )

多变量输出

print( , ,..., )

输出后的各变量值之间用一个空格分隔

混合输出

print( .format( , ,..., ) )

print("转换后的温度是{:.2f}F".format(F)) #当输出包含变量的字符串时，需要采用格式化输出方式：方法format()

# 无论用户在控制台输入什么内容，该函数都以字符串类型返回结果

三、Python语言特点

主要特点

通用性

语法简洁

生态高产

次要特点

平台无关

强制可读

支持中文

模式多样

类库便捷

3 基本数据类型

一、数字类型

1.整数类型

整数类型共有4种进制表示形式：十六进制，十进制，八进制，二进制，默认采用十进制。

整数类型的4种进制表示

进制种类

引导符号

描述

二级制

0b 或 0B

由字符 0 和 1 组成，例如，0b1010, 0B1010

八进制

0o 或 0O

由字符 0 到 7 组成，例如，0o1010, 0O1070

十进制

无

默认情况，例如：1010, -1010

十六进制

0x 或 0X

字符 0 到 9、a 到 f 或 A 到 F 组成，例如 0x1010, 0X10F0

2.浮点数类型

< a >e< b > = a x 10^b^

浮点数运算间存在不确定小尾数问题，可以通过 round( x, d ) 函数约定运算后保留小数的位数，d 控制小数点精读。

3.复数类型

a+bJ

z.real 获取实数部分

z.imag 获取虚数部分

二、数字类型的运算

1.数值运算操作符

操作符

描述

x + y

x 与 y 之和

x – y

x 与 y 之差

x * y

x 与 y 之积

x / y

x 与 y 之商(产生结果为浮点数，10/3结果是3.3333333333333335)

x // y

x 与 y 之整数商(不大于 x 与 y 之商的最大整数，10//3结果是3)

+x

x 本身

-x

x 的负值

x % y

x 与 y 之商的余数(模运算，10%3结果是1)

x ** y

x 的 y 次幂(幂运算，x^y^)

增强赋值操作符

x op= y 等价于 x = x op y(例如：x += y 与 x = x + y 等价)

x += y、x -= y、x = y、x /= y、x//=y、x%=y、x*=y

2.数值运算函数

函数

描述

abs( x )

x 的绝对值；abs(-10.01) 结果为 10.01

divmod( x, y )

( x//y, x%y )，同时输出商和余数；divmod(10, 3) 结果为 (3, 1)

pow( x, y[, z] )

( x**y )%z，参数 z 可省略；pow(10, 2, 3) 结果为 1

round( x[, d] )

对 x 四舍五入，保留 d 位小数，无参数 d 则默认返回整数；round(-10.123, 2) 结果为 -10.12

max( x^1^,x^2^, … ,x^n^ )

返回 x^1^,x^2^, … ,x^n^ 中的最大值，n不限；max(1, 9, 5, 4, 3) 结果为 9

min( x^1^,x^2^, … ,x^n^ )

返回 x^1^,x^2^, … ,x^n^ 中的最小值，n不限；min(1, 9, 5, 4, 3) 结果为 1

三、字符串类型及格式化

1.字符串索引

[序号]

2.字符串切片

[：：]

3.字符串格式化

.format()

槽用 {} 表示： {: }

将format()方法中逗号分隔的参数按照序号关系替换到模板字符串的槽中。

参数从 0 开始编号，如果大括号中没有序号，则按照出现顺序替换。

调用format()方法后会返回一个新的字符串。

：

填充

对齐

宽度

,

精度

类型

引导符号

用于填充的单个字符

< 左对齐 > 右对齐 ^ 居中对齐

槽的设定输出宽度

数字的千分符，适用于整数和浮点数

浮点数小数部分的精度或字符串的最大输出长度

整数：b、c、d、o、x、X 浮点数：e、E、f、% 字符串：s

print("{:>15s}:{:<8.2f}".format("Length",23.87501))

# Length:23.88

'''

例题：获得用户输入的一个字符串，格式如下:

M OP N‪‪

其中，M和N是任何数字，OP代表一种操作，表示为如下四种：+, -, *, /(加减乘除)

根据OP，输出M OP N的运算结果，统一保存小数点后2位。‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

注意：M和OP、OP和N之间可以存在多个空格，不考虑输入错误情况。

'''

n = input()

print("{:.2f}".format(eval(n)))

宽度、对齐、填充

s = "python"

"{0:30}".format(s)

# 'python '

# 默认左对齐

# 如果该槽对应的format()参数实际位数小于指定宽度，则位数被默认以空格字符填充

"{0:>30}".format(s)

# ' python'

# 右对齐

"{0:*^30}".format(s)

# '************python************'

# 居中且使用 * 填充

"{0:-^30}".format(s)

# '------------python------------'

# 居中且使用 - 填充

"{0:3}".format(s)

# 'python'

# 如果该槽对应的format()参数实际位数大于指定宽度，则使用参数实际长度

千位分隔符

"{0:-^20}".format(1234567890)

# '-----1234567890-----'

"{0:-^20,}".format(1234567890)

# '---1,234,567,890----'

# 格式控制标记中的逗号(,)用于显示数字类型的千位分隔符

"{0:-^20,}".format(12345.67890)

# '----12,345.6789-----'

精度

"{0:.2f}".format(12345.67890)

# '12345.68'

# .精度 由小数点(.)开头，有两个含义：

# 对于浮点数，精度表示小数部分输出的有效位数

# 对于字符串，精度表示输出的最大长度

"{0:H^20.3f}".format(12345.67890)

# 'HHHHH12345.679HHHHHH'

"{0:.4}".format("python")

# 'pyth'

类型

表示输出整数和浮点数类型的格式规则。

整数

b：整数的二级制形式

c：整数对应的Unicode字符

d：整数的十进制形式

o：整数的八进制形式

x：整数的小写十六进制形式

X：整数的大写十六进制形式

"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)

# '110101001,Ʃ,425,651,1a9,1A9'

浮点数

e：e的指数形式

E：E的指数形式

f：标准浮点形式

%：百分数形式

"{0:e},{0:E},{0:f},{0:%}".format(3.14)

# '3.140000e+00,3.140000E+00,3.140000,314.000000%'

"{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)

# '3.14e+00,3.14E+00,3.14,314.00%'

四、字符串操作

基本的字符串操作符

操作符

描述

x + y

连接两个字符串 x 与 y

x * n 或 n * x

复制 n 次字符串 x

x in s

如果 x 是 s 的子串，返回 True，否则返回 False

str[i]

索引，返回第 i 个字符

str[N: M]

切片，返回索引第 N 到第 M 的子串，其中不包含 M

内置的字符串处理函数

函数

描述

len(x)

返回字符串 x 的长度，也可返回其他组合数据类型元素个数

str(x)

返回任意类型 x 所对应的字符串形式

chr(x)

返回 Unicode 编码 x 对应的单字符

ord(x)

返回单字符表示的 Unicode 编码

hex(x)

返回整数 x 对应十六进制数的小写形式字符串

oct(x)

返回整数 x 对应八进制数的小写形式字符串

内置的字符串处理方法

方法

描述

str.lower()

返回字符串 str 的副本，全部字符小写

str.upper()

返回字符串 str 的副本，全部字符大写

str.islower()

当 str 所有字符都是小写时，返回 True，否则返回 False

str.isprintable()

当 str 所有字符都是可打印的，返回 True，否则返回 False

str.isnumeric()

当 str 所有字符都是数字时，返回 True，否则返回 False

str.isspace()

当 str 所有字符都是空格，返回 True，否则返回 False

str.endswith(suffix[,start[,end]])

str[start: end] 以 suffix 结尾返回 True，否则返回 False

str.startswith(prefix[,start[,end]])

str[start: end] 以 prefix 开始返回 True，否则返回 False

str.split(sep=None, maxsplit=-1)

返回一个列表，由 str 根据 sep 被分隔的部分构成

str.count(sub[,start[,end]])

返回 str[start,end] 中 sub 子串出现的次数

str.replace(old, new[, count])

返回字符串 str 的副本，所有 old 子串被替换为 new，如果 count 给出，则前 count 次 old 出现被替换

str.center(width[, fillchar])

字符串居中函数；width：字符串的总宽度；fillchar ：填充字符

str.strip([chars])

返回字符串 str 的副本，在其左侧和右侧去掉 chars 中列出的字符

str.zfill(width)

返回字符串 str 的副本，长度为 width，不足部分在左侧添0

str.format

返回字符串的一种排版格式

str.join(iterable)

返回一个新字符串，由组合数据类型iterable变量的每个字符组成，元素间用str分隔

a="张 木 楠"

a.split()

['张', '木', '楠']

五、类型判断和类型间转换

1.类型判断

type(3.1)

#

type(3)

#

type(str)

#

# 不带引号的一组字母会被视为“变量”，而非“字符串”

type('str')

#

2.类型间转换

函数

含义

int(x)

变整数(浮点数转整数时，小数部分会被舍弃)

float(x)

变浮点

str(x)

变字符串

复数不能直接转换成其他数字类型，可以通过.real和.imag将复数的实部和虚部分别转换。

complex(re[,im]) 生成一个复数，实部为re，虚部为im。

4 程序控制结构

一、3种控制结构

3种控制结构：顺序、分支、循环

t = x #赋值语句

x,y = y,x #同步赋值语句

二、程序的分支结构

1.单分支结构：if语句

if :

Python的关系操作符

操作符

数学符号

含义

<

<

小于

<=

≤

小于或等于

>=

≥

大于或等于

>

>

大于

==

=

等于

!=

≠

不等于

特别注意：Python使用“=”表示赋值语句，使用“==”表示等于。

字符串的比较

字符串比较本质上是字符串对应的Unicode编码的比较，因此字符串的比较按照字典顺序进行。例如，英文大写字符对应的Unicode编码比小写字符小。

4 < 5

# True

"python" == "python"

# True

"Python" > "python"

# False

2.二分支结构：if-else语句

if :

else:

二分支结构的简洁表达方式，通过判断返回特定值：

if else

count = 2

count if count!=0 else "不存在"

# "不存在"

PM = eval(input("请输入PM2.5数值："))

print("空气{}污染".format("存在" if PM >= 75 else "没有"))

3.多分支结构：if-elif-else语句

if :

elif :

else:

# if/elif/else都是保留字

# else后面不增加条件，表示不满足其他if语句的所有其余情况

# 条件后面要加冒号

'''

例如：分段函数求值

3x - 5(x > 1)

f(x) =x + 2(-1 <= x <= 1)

5x + 3(x < -1)

'''

x = eval(input("x = "))

if x > 1:

y = 3 * x - 5

elif x >= -1:

y = x + 2

else:

y = 5 * x + 3

print("f({:.2f}) = {:.2f}".format(x, y))

三、循环语句

1.遍历循环：for语句

for语句的循环执行次数是根据遍历结构中元素个数确定的。

遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于所提取的每个元素执行一次语句块。

for in :

# 遍历循环的扩展模式：

for in :

else:

# else语句只在循环正常执行并结束后才执行

# 因此可以在中放置判断循环执行情况的语句：

for s in "BIT":

print("循环进行中：" + s)

else:

s = "循环正常结束"

print(s)

'''

循环进行中：B

循环进行中：I

循环进行中：T

循环正常结束

'''

# 用for循环实现1~10之间的求和

sum = 0

for x in range(1, 11):

sum += x

print(sum)

range(start, stop[, step])

参数

含义

举例

start

计数从 start 开始。默认是从0开始。

range(5)等价于range(0， 5)

stop

计数到 stop结束，但不包括stop。

range(0， 5) 是[0, 1, 2, 3, 4]没有5

step

步长，默认为1。

range(0， 5) 等价于 range(0, 5, 1)

# 生成从0开始到9的整数序列: [1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(1,10))

2.无限循环/条件循环：while语句

当条件判断为 True 时，循环体重复执行语句块中语句；当条件为 False 时，循环终止，执行与 while 同级别缩进的后续语句。

while :

# 无限循环的扩展模式：

while :

else:

# else语句只在循环正常执行后才执行

# 因此可以在中放置判断循环执行情况的语句：

s, idx = "BIT", 0

while idx < len(s):

print("循环进行中：" + s[idx])

idx += 1

else:

s = "循环正常结束"

print(s)

'''

循环进行中：B

循环进行中：I

循环进行中：T

循环正常结束

'''

3.循环保留字：break 和 continue

break

跳出最内层 for 或 while 循环，脱离该循环后程序从循环代码后继续，每个 break 语句只有能力跳出当前层次循环。

for s in "BIT":

for i in range(10):

print(s, end="")

if s=="I":

break

# BBBBBBBBBBITTTTTTTTTT

continue

结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

for s in "PYTHON":

if s=="T":

continue

print(s, end="")

# PYHON

# continue 只结束本次循环，而不终止整个循环的执行

for s in "PYTHON":

if s=="T":

break

print(s, end="")

# PY

# break 结束整个循环过程，不再判断执行循环的条件

else扩展用法

for s in "PYTHON":

if s=="T":

continue

print(s, end="")

else:

print("正常退出")

# PYHON 正常退出

# continue 保留字对 else 没有影响

for s in "PYTHON":

if s=="T":

break

print(s, end="")

else:

print("正常退出")

# PY

# 存在 break 或 return 保留字，不再执行 else 后面的代码块

else 语句只在 循环 正常 执行 后 才执行！

'''

猜数字游戏

计算机出一个1~1000之间的随机数由人来猜

计算机根据人猜的数字分别给出提示大一点/小一点/猜对了

'''

import random

answer = random.randint(1, 1000)

counter = 0

while True:

counter += 1

number = int(input('请输入: '))

if number < answer:

print('大一点')

elif number > answer:

print('小一点')

else:

print('恭喜你猜对了!')

break

print('你总共猜了%d次' % counter)

if counter > 15:

print('你的智商余额明显不足')

四、程序的异常处理

1.异常处理：try-except语句

try:

#正常执行的程序内容

except :

#发生异常时执行

try:

num = eval(input("请输入一个整数："))

print(num**2)

except NameError:

print("输入错误，请输入一个整数！")

# 请输入一个整数：w

# 输入错误，请输入一个整数！

2.异常的高级用法

多个except语句：

try:

except :

# ...

except :

except:

与 else 和 finally 保留字配合使用：

try:

except :

else: #当 try 中的 语句块1 正常执行结束且未发生异常时，执行 语句块3

finally: #无论 try 中的 语句块1 是否发生异常，语句块4 都会执行

5 函数与代码复用

一、函数的定义和使用

函数的定义

def (): #可以没有参数，但括号不可省略

return

函数的调用过程

1.调用程序在调用处暂停执行

2.在调用时将 实参 复制给函数的 形参

3.执行函数体语句

4.函数调用结束给出返回值，程序回到调用前的暂停处继续执行

lambda函数/匿名函数

用于定义简单的，能够在一行内表示的函数

= lambda :

f = lambda x, y: x + y

二、函数的参数传递：可选参数的传递、参数名称传递、函数的返回值

1.可选参数的传递

def (, =):

return

2.参数名称传递

def (=):

return

3.函数的返回值

可以没有return

可有多个return

三、变量的作用域：局部变量和全局变量

全局变量：在函数之外定义的变量，一般没有缩进，在程序执行全过程有效

局部变量：在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在

原则：

1.简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放，如有全局同名变量，其值不变。

2.简单数据类型变量在用 global 保留字声明后，作为全局变量使用，函数退出后该变量保留且值被函数改变。

3.对于组合数据类型的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值。

4.如果函数内部真实创建了组合数据类型变量，无论是否有同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量值不变。

global

n = 1 #n是全局变量

def func(a, b):

global n

n = b #将局部变量b赋值给全局变量n

return a*b

s = func("knock~", 2)

print(s, n) #n值发生改变

# knock~knock~ 2

6 组合数据类型

一、组合数据类型的基本概念

序列类型：是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。包括：字符串 (str) 类型、元组 (tuple) 类型、列表 (list) 类型。

集合类型：是一个元素集合 (set)，元素之间无序，相同元素在集合中唯一存在。

映射类型：字典 (map) 是”键-值“数据项的组合，每个元素是一个键值对，表示为 (key, value)。

组合数据类型

表示方法

集合类型

{ }

字符串类型

单引号(必须在一行)、双引号(必须在一行)、三引号(可以多行)

元组类型

( ) (圆括号为可选)

列表类型

[ ]

映射类型

{ }

集合类型的操作符

操作符及运算

描述

S - T

返回一个新集合，包括在集合 S 中但不在集合 T 中的元素

S -= T

更新集合S，包括在集合S但不在T中的元素

S & T

返回一个新集合，包括同时在集合 S 和 T 中的元素

S &= T

更新集合S，包括同时在集合 S 和 T 中的元素

S ^ T

返回一个新集合，包括集合 S 和 T 中非共同元素

S ^= T

更新集合S，包括集合 S 和 T 中的非相同元素

S | T

返回一个新集合，包括集合 S 和 T 中所有元素

S |= T

更新集合S，包括在集合S和T中的所有元素

S <= T 或 S < T

返回True/False，判断S和T的子集关系

S >= T 或 S > T

返回True/False，判断S和T的包含关系

集合类型常用的操作函数或方法

操作函数或方法

描述

S.add(x)

如果数据项 x 不在集合 S 中，将 x 增加到 S

S.clear()

移除集合 S 中所有元素

S.copy()

返回集合 S 的一个副本

S.pop()

随机返回集合 S 的一个元素，若 S 为空产生 KeyError 异常

S.discard(x)

如果 x 在集合 S 中，移除 S；不在也不报错

S.remove(x)

如果 x 在集合 S 中，移除 S；不在则产生 KeyError 异常

S.isdisjoint(T)

如果集合 S 与 T 没有相同元素，返回True

len(S)

返回集合 S 的元素个数

x in S

如果元素 x 在集合 S 中，返回True，否则返回False

x not in S

如果元素 x 不在集合 S 中，返回True，否则返回False

二、列表类型：定义、索引、切片

与字符串类型索引、切片相同

三、列表类型的操作：列表的操作函数、列表的操作方法

1.操作函数

操作函数

描述

len( ls )

列表 ls 的元素个数(长度)

min( ls )

列表 ls 中的最小元素

max( ls )

列表 ls 中的最大元素

list( x )

将 x 转变成列表类型

2.操作方法

方法

描述

ls.append( x )

在列表 ls 最后增加一个元素 x

ls.insert( i, x )

在列表 ls 第 i 位置增加元素 x

ls.clear()

删除列表 ls 中的所有元素

ls.pop( i )

将列表 ls 第 i 项元素取出并删除该元素

ls.remove( item )

将列表中出现的第一个元素 item 删除

ls.reverse()

将列表 ls 中元素反转

ls.copy()

生成一个新列表，复制 ls 中所有元素

四、字典类型：定义、索引

定义： = { : , : , …, : }

索引： = [ ]

五、字典类型的操作：字典的操作函数、字典的操作方法

1.操作函数

操作函数

含义

len( d )

字典 d 的元素个数(长度)

min( d )

字典 d 中键的最小值

max( d )

字典 d 中键的最大值

dist()

生成一个空字典

2.操作方法

操作函数

含义

d.keys()

返回所有键信息

d.values()

返回所有值信息

d.items()

返回所有键值对

d.get(key,defaut)

键存在则返回对应值，否则返回默认值

d.pop(key,default)

键存在则返回对应值，同时删除该键值对，否则返回默认值

d.popitem()

随机从字典中取出一个键值对，以元组形式(key, value)形式返回

d.clear()

删除所有的键值对

7 文件和数据格式化

一、文件的使用：文件打开、关闭和读写

1.文件打开

= open(, )

textFile = open("aaa.txt", "rt") #t表示采用文本文件方式打开

print(textFile.readline())

textFile.close() #文件关闭

textFile = open("aaa.txt", "rb") #b表示采用二进制文件方式打开

print(textFile.readline())

textFile.close()

文件的打开模式

打开模式

含义

'r'

只读模式，文件不存在，则返回异常FileNotFoundError

'w'

覆盖写模式，文件不存在则创建，存在则完全覆盖

'x'

创建写模式，文件不存在则创建，存在则返回异常FileExistsError

'a'

追加写模式，文件不存在则创建

'b'

二进制文件模式

't'

文本文件模式

'+'

与r/w/x/a一同使用，在原有功能基础上增加同时读写功能

2.文件关闭

.close()

3.文件读取

方法

含义

f.read( size=-1 )

从文件中读入整个文件内容，如果给出参数，读入前size长度的字符串或字节流

f.readline( size=-1 )

从文件中读入一行内容，如果给出参数，读入该行前size长度的字符串或字节流

f.readlines( hint=-1 )

从文件中读入所有行，以每行为元素形成一个列表，如果给出参数，读入hint行

f.seek( offset )

改变当前文件操作指针，offset 的值：0 文件开头；1 当前位置；-1 文件结尾

4.文件写入

方法

含义

f.write( s )

向文件写入一个字符串或字节流

f.writelines( lines )

将一个元素全为字符串的列表写入文件

fname = input("请输入要写入的文件：")

fo = open(fname, "w+") #文件打开，覆盖写模式

ls = ["唐诗", "宋词", "元曲"]

fo.writelines(ls) #将一个元素全为字符串的列表写入文件

fo.seek(0) #将文件操作指针返回到文件开始

for line in fo:

print(line)

fo.close() #文件关闭

二、数据组织的维度：一维数据、二维数据

一维数据：由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中数组或集合的概念。

二维数据：也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵。常见的表格都属于二维数据。

多维数据：键值对构成的数据形式。

三、一维数据的处理：表示、存储和处理

一维数据：主要采用列表形式表示；对于一组无序数据，也可以采用集合形式表示。

.split( ) 方法

# 导入CSV格式数据到列表

fo = open("p.csv", "r") #打开文件

ls = [] #创建空列表

for line in fo: #遍历循环

line = line.replace("\n", "") #去除每行末尾的换行符

ls.append(line.split(",")) #将数据写入列表

print(ls)

fo.close() #关闭文件

.join( ) 方法

# 一维数据写入CSV文件

fo = open("p.csv", "w") #打开文件

ls = ['Shanghai', '1', '2'] #创建列表

fo.write(",".join(ls)+ "\n")

fo.close()

# 逐行写入参考代码

for row in ls:

fo.write(",".join(row)+ "\n")

四、二维数据的处理：表示、存储和处理

二维数据：由多条一维数据构成，可以看成是一维数据的组合形式。

二维数据处理等同于二维列表的操作，一般需要借助两层循环遍历实现对每个数据的处理：

for row in ls:

for item in row:

五、采用CSV格式对一二维数据文件读写

CSV：Comma-Separated Values

CSV文件的每一行是一维数据，整个文件是一个二维数据。

8 Python计算生态

标准库：turtle 库、random库 、time 库(可选)

第三方库：PyInstaller、jiaba、wordcloud(可选)

更广发的计算生态

领域

库名

网络爬虫

requests、scrapy、pyspider

数据分析

numpy、pandas、scipy

文本处理

pdfminer、python-docx、beautifulsoup4

数据可视化

matplotlib、seaborn、mayavi

用户图形界面

PyQt5、wxPython、PyGObject

机器学习

scikit-learn、pyramid、flask

web开发

Django、pyramid、flask

游戏开发

pygame、Panda3d、cocos2d

大数据分析

opencv-python、NLTK、networkx

9 Python标准库概览

一、turtle函数库语法

1.绘图窗体坐标体系

turtle.setup(width,height,startx,starty)

setup不是必须的

参数

意思

备注

width

窗口宽度

整数表示像素值，小数表示与屏幕比例

height

窗口高度

整数表示像素值，小数表示与屏幕比例

startx

窗口左侧与屏幕左侧距离

None，位于水平中央

starty

窗口顶部与屏幕顶部距离

None，位于垂直中央

2.画笔控制函数

函数

简称

意思

参数含义

turtle.penup()

turtle.up或turtle.pu

抬笔

turtle.pendown()

turtle.down或turle.pd

落笔

turtle.pensize(width)

turtle.width

画笔尺寸

width：画笔线条宽度，

若为None或空，则返回当前画笔宽度

turtle.color(colorstring)

或turtle.color((r,g,b))

画笔颜色

colorstring:表示颜色的英文字符，如："red";

(r,g,b)：对应RGB值

3.形状绘制函数

函数

简称

意思

参数含义

turtle.fd(distance)

turtle.forward(distance)

前进

distance：距离

turtle.seth(to_angle)

turtle.setheading(to_angle)

改变方向

to_angle：绝对方向的角度值

turtle.circle(radius,extent)

绘制弧形

radius：半径；

extent：弧形角度

turtle.goto(x,y)

二、random库

函数

含义

参数

.seed(a=None)

初始化随机数种子 a，默认值为当前系统时间

a：随机种子，可以是整数、浮点数，只要种子相同，每次生成的随机数序列也相同

.random()

生成一个[0.0, 1.0)之间的随机小数

.randiant(a, b)

生成一个[a, b]之间的随机整数

a：开始数，整数；b：结束数，包括结束值整数

.getrandbits(k)

生成一个 k 比特长度的随机整数

k：长度的整数

.randrange(start, stop[, step])

生成一个[start, stop)之间以 step 为步长的随机整数

step：步长，结果必是其a+n*step，默认是1

.uniform(a, b)

生成一个[a, b]之间的随机小数

.choice(seq)

从序列类型，例如列表中随机返回一个元素

seq：序列类型

.shuffle(seq)

将序列类型 seq 中元素随机排列，返回打乱后的的序列

seq：序列类型，调用该函数后，序列类型变量seq将被改变

.sample(pop, k)

从pop类型中随机选取 k 个元素，以列表类型返回

三、time库

1.时间处理

函数

含义

参数

.time()

返回当前时间戳

.gmtime()

返回当前时间戳对应的struct_time对象

.localtime()

返回当前时间戳对应的本地时间的struct_time对象

.ctime()

返回当前时间戳所对应的易读字符串

from time import *

time()

# 1582716310.8309927

gmtime()

time.struct_time(tm_year=2020, tm_mon=2, tm_mday=26, tm_hour=11, tm_min=25, tm_sec=18, tm_wday=2, tm_yday=57, tm_isdst=0)

localtime()

time.struct_time(tm_year=2020, tm_mon=2, tm_mday=26, tm_hour=19, tm_min=26, tm_sec=52, tm_wday=2, tm_yday=57, tm_isdst=0)

ctime()

# 'Wed Feb 26 19:27:27 2020'

2.时间格式化

函数

含义

参数

.mktime(t)

将struct_time对象变量t转换为时间戳

t：代表时间的struct_time对象变量

.strftime(format,t)

根据format格式定义打印输出t

.strptime(string,format)

根据format格式定义，解析字符串string，返回struct_time类型时间变量

from time import *

t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)

mktime( t )

# 1234861418.0

格式化字符串

星期/时间

%Y

年份

%m

月份

%B

月名

%b

月名缩写

%d

日期

%A

星期

%a

星期缩写

%H

小时(24h)

%I

小时(12h)

%p

上午/下午

%M

分钟

%S

秒

3.计时

函数

含义

参数

.sleep(secs)

将当前程序挂起secs秒，挂起即停止执行

secs：表示时间的数值

.perf_counter()

返回一个代表时间的精确浮点数，两次或多次调用，其差值用来计时

10 Python第三方库概览

一、pip命令

pip工具的安装

在cmd下操作

获取帮助

pip -h

安装第三方安装包 pip install

安装包不区分大小写

pip install pyinstaller

pip install jiaba

获取已安装第三方包列表

pip list

检查是否有需要更新的第三方库

pip list -o

更新第三方库 pip install --upgrade

pip install --upgrade colorama

查询库信息 pip show pip install --upgrade

pip show panda

卸载第三方库 pip uninstall

pip uninstall panda

搜索 pip search

pip search panda

下载但不安装pip download

pip download pandas

配置国内镜像安装地址(非考点)

解决网速过慢问题

清华大学pip镜像站

pip install pip -U

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

二、PyInstaller库

在cmd执行

pyinstaller

打包

pyinstaller -F

生成独立可执行文件

pyinstaller -I <.ico> -F

指定一个图标文件

文件名包括绝对或相对路径

三、jieba库

函数

作用

参数

.lcut(x)

精准模式

.lcut(x,cut_all=Ture)

全模式

.lcut_for_search(x)

搜索引擎模式

.add_word(w)

向分词词典中增加新词w

四、wordcloud库

import wordcloud

w = wordcloud.WordCloud().generate(txt)

w.to_file("wordcloud.png")

11 Python第三方库纵览