超详细的python基础语法总结

python六种标准的数据类型分别是Number（数字）String（字符串）List（列表）Tuple（元组）Set（集合）Dictionary（字典）
不可以变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：List（列表）、Dictionary（字典）、Set（集合）
和C不同，Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

1.数字

支持整型(Int)，浮点型(float)，复数( (complex))三种数值类型

类型说明：

整型，Python3 整型是没有限制大小的，可以当作 Long 类型使用
浮点型，浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

数字类型转换：

int(x)，将x转换为整数

a = 100.0
b = int(a)
print(a)
print(b)
..........................
结果如下：
100.0
100 

float(x)，将x转换为浮点数

a = 100.0
b = float(a)
print(a)
print(b)
........................
结果如下：
100
100.0

complex(x)和complex(x,y)将x(x,y)转换为复数

print(complex(100))
print(complex(100,10))
........................
结果如下：
(100+0j)
(100+10j)

数字运算：

运算符	语法	意义
+	a+b	加法运算，和C语言的一样
-	a-b	减法运算，和C语言的一样
*	a*b	乘法运算，和C语言一样
/	a/b	除法运算，总返回一个浮点数结果
//	a//b	除法运算，丢弃小数部分，返回一个整数结果
%	a%b	取余运算，和C语言一样
**	a**n	幂运算，n为幂

注意：
不同类型的数混合运算时会将整数转换为浮点数

print(10/2*3)
........................
结果如下：
15.0

常用的随机函数：

函数名	语法	意义
choice	choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
randrange	randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random	random()	随机生成下一个实数，它在[0,1)范围内

注意：以上几个随机函数输入random模块内置函数，需要import random

2.字符串

字符串是 Python 中最常用的数据类型，可以使用单引号（’’）或者双引号（""）来创建字符串

var1 = 'Hello World!'
var2 = "https://blog.csdn.net/muchong123"
print(var1)
print(var2)
........................
结果如下：
Hello World!
https://blog.csdn.net/muchong123

访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用
Python 访问子字符串，可以使用方括号来截取字符串

var = 'Hello World!'
print(var[0]) #下标从0开始，表示从字符串的第一个字符开始算起
print(var[:5])
print(var[6:])
print(var[2:5])
print(var[-1:]) #下标从-1开始，表示从字符串的最后一个字符开始算起
print(var[-6:-2]) 
........................
结果如下：
H
Hello
World!
llo
!
Worl

字符串拼接

使用符号+可以进行字符串拼接

var = 'Hello World!'
print ("已更新字符串 : ", var[:6] + "every day!")
........................
结果如下：
已更新字符串 :  Hello every day!

常见字符串转义

在需要在字符中使用特殊字符时，python用反斜杠()转义字符，如果不需要转义，可在字符串前面加符号r

转义符	意义
(在行尾时)	续行符
\	反斜杠符号
’	单引号
"	双引号
\n	换行
\r	回车

字符串运算符

下表实例变量a值为字符串 “Hello”，b变量值为 “Python”：

操作符	意义	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法	print( r’\n’ ) print( R’\n’ )
%	格式字符串	内容涉及比较多详细使用，后一节讲

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中，在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法

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

python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
........................
结果如下：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( 	 )。
也可以使用换行符 [ 
 ]。

3.列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现，列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

list1 = ['john', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符

list1 = ['john', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
........................
结果如下：
list1[0]:  john
list2[1:5]:  [2, 3, 4, 5]

列表更新

对列表的数据项可以进行修改或更新，也可以使用append()方法来添加列表项

list = ['john', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
list.append('新增项目')
print ("更新后的第三个元素为 : ", list[2])
print("更新后的列表为："， list)
........................
结果如下：
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表为： ['john', 'Runoob', 2001, 2000, '新增项目']

删除列表元素

可以使用 del 语句来删除列表的的元素

list = ['john', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素后 : ", list)
........................
结果如下：
原始列表 :  ['john', 'Runoob', 1997, 2000]
删除第三个元素后 :  ['john', 'Runoob', 2000]

列表脚本操作符

表达式	结果	意义
en([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

列表拼接

L=['Google', 'Baidu', 'Taobao']
print("列表拼接前：", L)
L += ['Tengxun', 'Jingdong']
print("列表拼接后：", L)
........................
结果如下：
列表拼接前： ['Google', 'Baidu', 'Taobao']
列表拼接后： ['Google', 'Baidu', 'Taobao', 'Tengxun', 'Jingdong']

列表函数&方法

函数	意义
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

方法	意义
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

4.元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改
元组使用小括号，列表使用方括号，
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

创建元组

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

tup1 = (50)
print(type(tup1))     # 不加逗号，类型为整型
tup2 = (50,)
print(type(tup2))     # 加上逗号，类型为元组
........................
结果如下：
<class 'int'>
<class 'tuple'>

访问元组

元组可以使用下标索引来访问元组中的值

tup1 = ('john', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
........................
结果如下：
tup1[0]:  john
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = ('Taobao', 'Tengxun', 'Baidu')
tup2 = ('Geogle', 'Jingdong')
# 以下修改元组元素操作是非法的。
# tup1[0] = 'Wangyu'
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
........................
结果如下：
('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')
print (tup)
del tup
print ("删除后的元组 tup : ", tup)
........................
结果如下：
('Taobao', 'Tengxun', 'Baidu', 'Geogle', 'Jingdong')
Traceback (most recent call last):
  File "E:\tup.py", line 4, in <module>
    print ("删除后的元组 tup : ", tup)
NameError: name 'tup' is not defined

元组运算符

表达式	结果	意义
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

元组内置函数

函数	意义
len(tuple)	计算元组元素个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(iterable)	将可迭代系列转换为元组

5.字典

字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，格式如下：
d = {key1 : value1, key2 : value2 }
注意：
键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

创建字典

dict = {'Alice': '16', 'Beth': '18', 'Cecil': '21'}
print(dict)
........................
结果如下：
{'Alice': '16', 'Beth': '18', 'Cecil': '21'}

访问字典里的值

dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
print ("dict[Name]: ", dict['Name'])
print ("dict[Age]: ", dict['Age'])
........................
结果如下：
dict[Name]:  Ben
dict[Age]:  15

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值

dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
dict['Age'] = 16               # 更新 Age
dict['School'] = "xx Meddle School"  # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
........................
结果如下：
dict['Age']:  16
dict['School']:  xx Meddle School

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作
显示删除一个字典用del命令

dict = {'Name': 'Ben', 'Age': 15, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
print ("dict['Age']: ", dict['Age'])
........................
结果如下：
Traceback (most recent call last):
  File "E:\dict.py", line 5, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable

字典内置函数&方法

函数	意义
len(dict)	计算字典元素个数，即键的总数
str(dict)	输出字典，以可打印的字符串表示
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型

方法	意义
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
radiansdict.items()	以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys()	返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.values()	返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的最后一对键和值