蓝桥杯系列2——python基本语法_格式化操作符辅助指令怎么用

零

看课本收货良多，因此对照菜鸟教程把python基本语法对着敲了一下。
这部分看起来很多，但实际只花了一个下午。写给自己以后复习看。

你好，世界

print ("你好，世界")
1

你好，世界
1

Python 变量类型

变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

print(counter,miles,name)
1
2
3
4
5

100 1000.0 John
1

多变量赋值

a, b, c = 1, 2, "john"
print(a,b,c)
1
2

1 2 john
1

标准数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

不可变：Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）

数字

数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时，Number 对象就会被创建：

var1 = 1
var2 = 10
1
2

del var1 # 删除单个或多个对象的引用
1

var1
1

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_21312/2376987541.py in <module>
----> 1 var1


NameError: name 'var1' is not defined
1
2
3
4
5
6
7
8
9

Python支持四种不同的数字类型：

int（有符号整型）

long（长整型，也可以代表八进制和十六进制） 0122L

float（浮点型）

complex（复数） 4.53e-7j

字符串

[头下标:尾下标] 来截取相应的字符串，从 0 开始。

[头下标:尾下标] 获取的子字符串[头，尾)。

访问字符串的值

s = 'abcdef'
s[1:5]
1
2

'bcde'
1

字符串连接

加号（+）是字符串连接运算符，星号（*）是重复操作。

str = 'Hello World!'
 
print (str )          # 输出完整字符串
print (str[0])        # 输出字符串中的第一个字符
print (str[2:5] )     # 输出字符串中第三个至第六个之间的字符串
print (str[2:]  )     # 输出从第三个字符开始的字符串
print (str * 2 )      # 输出字符串两次
print (str + "TEST")  # 输出连接的字符串
1
2
3
4
5
6
7
8

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
1
2
3
4
5
6

列表截取第三个参数:截取的步长

letters='abcdefg'
letters[1:4:2]
1
2

'bd'
1

列表

List（列表）用 [ ] 标识，支持字符，数字，字符串甚至可以包含列表（即嵌套）。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print (list  )             # 输出完整列表
print (list[0]  )          # 输出列表的第一个元素
print (list[1:3]  )        # 输出第二个至第三个元素 
print (list[2:]  )         # 输出从第三个开始至列表末尾的所有元素
print (tinylist * 2 )      # 输出列表两次
print (list + tinylist)    # 打印组合的列表
1
2
3
4
5
6
7
8
9

['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
1
2
3
4
5
6

元组

用 () 标识。内部元素用逗号隔开。

不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print (tuple   )            # 输出完整元组
print (tuple[0]   )         # 输出元组的第一个元素
print (tuple[1:3]  )        # 输出第二个至第四个（不包含）的元素 
print (tuple[2:]   )        # 输出从第三个开始至列表末尾的所有元素
print (tinytuple * 2   )    # 输出元组两次
print (tuple + tinytuple)   # 打印组合的元组
1
2
3
4
5
6
7
8
9

('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
1
2
3
4
5
6

字典

字典(dictionary)。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 

print (dict['one']  )        # 输出键为'one' 的值
print (dict[2])              # 输出键为 2 的值
print (tinydict )            # 输出完整的字典
print (tinydict.keys())      # 输出所有键
print (tinydict.values()   ) # 输出所有值
1
2
3
4
5
6
7
8
9
10
11
12

This is one
This is two
{'name': 'runoob', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['runoob', 6734, 'sales'])
1
2
3
4
5

数据类型转换

需要对数据内置的类型进行转换,数据类型作为函数名。

返回一个新的对象，表示转换的值。

函数 描述
int(x [,base]) 将x转换为一个整数

long(x [,base] ) 将x转换为一个长整数

float(x) 将x转换到一个浮点数

complex(real [,imag]) 创建一个复数

str(x) 将对象 x 转换为字符串

repr(x) 将对象 x 转换为表达式字符串

eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s) 将序列 s 转换为一个元组

list(s) 将序列 s 转换为一个列表

set(s) 转换为可变集合

dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s) 转换为不可变集合

chr(x) 将一个整数转换为一个字符

unichr(x) 将一个整数转换为Unicode字符

ord(x) 将一个字符转换为它的整数值

hex(x) 将一个整数转换为一个十六进制字符串

oct(x) 将一个整数转换为一个八进制字符串

运算符

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级

• • • / % ** //
      除数为浮点数，结果才为浮点数

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c = a - b
print ("2 - c 的值为：", c )
 
c = a * b
print ("3 - c 的值为：", c )
 
c = a / b
print ("4 - c 的值为：", c )
 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)
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

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2
1
2
3
4
5
6
7

位运算

按位运算符是把数字看作二进制来进行计算的。

& 与 | 或 ^ 异或 ~ 取反 << 左移（高位丢弃，低位补零） >> 右移

逻辑运算

and or not 返回布尔值

成员运算符

in
返回布尔值
not in
判断：是否同一内存空间

条件语句

通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

条件之间，and或者or连接

if elif else

循环语句

while for 嵌套

while 1： #循环必然成立，靠break跳出循环

循环控制语句

break跳出当个循环 continue跳出当次循环 pass占位语句

continue 语句是一个删除的效果，他的存在是为了删除满足循环条件下的某些不需要的成分

pass定义空函数

def sample(n_samples):
pass

循环使用else语句

while … else 在循环条件为 false 时执行 else 语句块

count = 0
while count < 5:
    print( count, " is  less than 5")
    count = count + 1
else:
    print( count, " is not less than 5")
1
2
3
4
5
6

0  is  less than 5
1  is  less than 5
2  is  less than 5
3  is  less than 5
4  is  less than 5
5  is not less than 5
1
2
3
4
5
6

Number(数字)

不允许改变，改变数值将重新分配内存空间

math 模块、cmath 模块

math 模块提供了许多对浮点数的数学运算函数。

cmath 模块包含了一些用于复数运算的函数。

# 查看 math 查看包中的内容:

import math
dir(math)
1
2
3
4

['__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'acos',
 'acosh',
 'asin',
 'asinh',
 'atan',
 'atan2',
 'atanh',
 'ceil',
 'comb',
 'copysign',
 'cos',
 'cosh',
 'degrees',
 'dist',
 'e',
 'erf',
 'erfc',
 'exp',
 'expm1',
 'fabs',
 'factorial',
 'floor',
 'fmod',
 'frexp',
 'fsum',
 'gamma',
 'gcd',
 'hypot',
 'inf',
 'isclose',
 'isfinite',
 'isinf',
 'isnan',
 'isqrt',
 'lcm',
 'ldexp',
 'lgamma',
 'log',
 'log10',
 'log1p',
 'log2',
 'modf',
 'nan',
 'nextafter',
 'perm',
 'pi',
 'pow',
 'prod',
 'radians',
 'remainder',
 'sin',
 'sinh',
 'sqrt',
 'tan',
 'tanh',
 'tau',
 'trunc',
 'ulp']
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

数学函数

函数 返回值 ( 描述 )
abs(x) 绝对值，如abs(-10) 返回 10
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 浮点数绝对值，如math.fabs(-10) 返回10.0
ceil(x) 上入整数，如math.ceil(4.1) 返回 5
floor(x) 下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…) 最大值，参数可以为序列。
min(x1, x2,…) 最小值，参数可以为序列。
modf(x) x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x ** y 运算后的值
round(x [,n]) 浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 数字x的平方根## 随机函数
choice(seq) 从序列元素中随机挑选一个元素，如random.choice(range(10)),从0到9中随机取一个整数
randrange([start,] stop [,step])从指定基数递增集合获取一个随机数
random() 随机生成一个实数，[0,1)范围内
seed([x])改变随机数生成的种子seed
shuffle(lst) 将序列的所有元素随机排序
uniform(x,y) 随机生成下一个实数，在[x,y]范围内

三角函数

asin(x) 反余弦弧度值

数学常量

pi
e

字符串

var[2:5] [2,5)

var1[:6] + 'Runoob!

转义字符

’

\b 退格

\000 空

\v 纵向制表符

\t 横向制表符

\r 回车

print('\000'+'1')
print('1')
1
2

1
1
1
2

• 连接 * 重复输出 in 包含返回True r 原始字符串

print(r'\n')
1

\n
1

格式化输出

print("My name is %s and weight is %d kg!" % ('Zara',21))
1

My name is Zara and weight is 21 kg!
1

格式化符号

%c ASCII码

%s 字符串

%d 整数

%u 无符号整数

%o 八进制 %x 十六进制 %X 大写十六进制

%f 浮点数字，可指定精度

%e 科学计数法表示浮点数

% 十六进制输出变量地址

格式化操作符辅助指令

• 宽度获小数点精度

• 左对齐

• 正数前面显示+
  正数前面显示空格

八进制数前面显示(‘0’)

0 显示数字前面填充’0’而不是默认空格
%% 输出%
(var) 映射变量
m.n. m显示最小总宽度,n是小数点位数
str.format 格式化函数string.capitalize() 字符串第一个字符大写
string.count() 返回出现次数
string.find() 检测是否包含
string.replace(str1,str2)
string.rfind() 返回最后一次出现的次数
string.upper() 转换为大写
string.lower() 转化为小写

if tmp_fun()==fun_tmp().decode("gbk"):
    print("eq")
'''
  decode("gbk")作用为将gbk编码转为unicode编码
'''
1
2
3
4
5

列表

list1 = ['physics', 'chemistry', 1997, 2000]
print("list1[1:5]: ", list1[1:5])

list1.append('Runoob') # 增加
print(list1)

del list1[2] # 删除
print(list1)
1
2
3
4
5
6
7
8

list1[1:5]:  ['chemistry', 1997, 2000]
['physics', 'chemistry', 1997, 2000, 'Runoob']
['physics', 'chemistry', 2000, 'Runoob']
1
2
3

print(list1[1:])
print(list1[-1])
print(list1[2])
1
2
3

['chemistry', 2000, 'Runoob']
Runoob
2000
1
2
3

列表函数

cmp(list1, list2) 比较两个列表的元素

len(list) 列表元素个数

max(list) 返回列表元素最大值

min(list) 返回列表元素最小值

list(seq) 将元组转换为列表

列表方法

list.append() 添加对象

list.count() 统计出现次数

list.extend() 新列表扩充原列表

list.index() 列表找出某个值第一个匹配项的索引位置

list.insert() 将对象插入列表

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），返回该元素的值

list.remove() 移除列表中某一个值的第一个匹配项

list.reverse() 反向列表元素

list.sort(reverse=False) 对原列表进行排序

元组

元组元素不能修改 （），隔开

tup1 = ('physics', 'chemistry', 1997, 2000)
#元组中只包含一个元素时，需要在元素后面添加逗号
tup2 = (50,)
print("tup1[0]: ", tup1[0])
1
2
3
4

tup1[0]:  physics
1

修改元组：可以连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
1
2
3
4
5
6
7
8
9

(12, 34.56, 'abc', 'xyz')
1

删除元组:使用del语句来删除整个元组

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组

内置函数

tuple(seq) 将列表转换为元组

字典

可变容器，可存储任意类型对象

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

1