零
看课本收货良多，因此对照菜鸟教程把python基本语法对着敲了一下。
这部分看起来很多，但实际只花了一个下午。写给自己以后复习看。
你好，世界
print ("你好，世界")
你好，世界
Python 变量类型
变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
counter = 100 # 赋值整型变量 miles = 1000.0 # 浮点型 name = "John" # 字符串 print(counter,miles,name)
100 1000.0 John
多变量赋值
a, b, c = 1, 2, "john" print(a,b,c)
1 2 john
标准数据类型
在内存中存储的数据可以有多种类型。
例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：
不可变：Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
数字
数字数据类型用于存储数值。
他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时，Number 对象就会被创建：
var1 = 1 var2 = 10
del var1 # 删除单个或多个对象的引用
var1
--------------------------------------------------------------------------- NameError Traceback (most recent call last) ~\AppData\Local\Temp/ipykernel_21312/2376987541.py in <module> ----> 1 var1 NameError: name 'var1' is not defined
Python支持四种不同的数字类型：
int（有符号整型）
long（长整型，也可以代表八进制和十六进制） 0122L
float（浮点型）
complex（复数） 4.53e-7j
字符串
[头下标:尾下标] 来截取相应的字符串，从 0 开始。
[头下标:尾下标] 获取的子字符串[头，尾)。
访问字符串的值
s = 'abcdef' s[1:5]
'bcde'
字符串连接
加号（+）是字符串连接运算符，星号（*）是重复操作。
str = 'Hello World!' print (str ) # 输出完整字符串 print (str[0]) # 输出字符串中的第一个字符 print (str[2:5] ) # 输出字符串中第三个至第六个之间的字符串 print (str[2:] ) # 输出从第三个字符开始的字符串 print (str * 2 ) # 输出字符串两次 print (str + "TEST") # 输出连接的字符串
Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST
列表截取第三个参数:截取的步长
letters='abcdefg' letters[1:4:2]
'bd'
列表
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) # 打印组合的列表
['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']
元组
用 () 标识。内部元素用逗号隔开。
不能二次赋值，相当于只读列表。
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) # 打印组合的元组
('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')
字典
字典(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() ) # 输出所有值
This is one This is two {'name': 'runoob', 'code': 6734, 'dept': 'sales'} dict_keys(['name', 'code', 'dept']) dict_values(['runoob', 6734, 'sales'])
数据类型转换
需要对数据内置的类型进行转换,数据类型作为函数名。
返回一个新的对象，表示转换的值。
函数 描述
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 - c 的值为： 31 2 - c 的值为： 11 3 - c 的值为： 210 4 - c 的值为： 2.1 5 - c 的值为： 1 6 - c 的值为： 8 7 - c 的值为： 2
位运算
按位运算符是把数字看作二进制来进行计算的。
& 与 | 或 ^ 异或 ~ 取反 << 左移（高位丢弃，低位补零） >> 右移
逻辑运算
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")
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
Number(数字)
不允许改变，改变数值将重新分配内存空间
math 模块、cmath 模块
math 模块提供了许多对浮点数的数学运算函数。
cmath 模块包含了一些用于复数运算的函数。
# 查看 math 查看包中的内容: import math dir(math)
['__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']
数学函数
函数 返回值 ( 描述 )
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 1
- 连接 * 重复输出 in 包含返回True r 原始字符串
print(r'\n')
\n
格式化输出
print("My name is %s and weight is %d kg!" % ('Zara',21))
My name is Zara and weight is 21 kg!
格式化符号
%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编码 '''
列表
list1 = ['physics', 'chemistry', 1997, 2000] print("list1[1:5]: ", list1[1:5]) list1.append('Runoob') # 增加 print(list1) del list1[2] # 删除 print(list1)
list1[1:5]: ['chemistry', 1997, 2000] ['physics', 'chemistry', 1997, 2000, 'Runoob'] ['physics', 'chemistry', 2000, 'Runoob']
print(list1[1:]) print(list1[-1]) print(list1[2])
['chemistry', 2000, 'Runoob'] Runoob 2000
列表函数
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])
tup1[0]: physics
修改元组：可以连接组合
tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3)
(12, 34.56, 'abc', 'xyz')
删除元组:使用del语句来删除整个元组
无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组
内置函数
tuple(seq) 将列表转换为元组
字典
可变容器，可存储任意类型对象
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
