基础教程
基础语法
标识符
标识符的定义
标识符(identifier)是指用来标识某个实体的一个符号,在不同的应用环境下有不同的含义。在计算机编程语言中,标识符是用户编程时使用的名字,用于给变量、常量、函数、语句块等命名,以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。
命名规则
-
第一个字符必须是字母表中字母或下划线
_
-
标识符的其他的部分由字母、数字和下划线组成。
-
标识符对大小写敏感。
-
保留字即关键字,我们不能把它们用作任何标识符名称。
Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:
import keyword print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
注释
python一共有3种注释的形式
- 单行注释:以#开头
- 多行注释:可以用多个 # 号,还有 ‘’’ 和 “”"
#!/usr/bin/python3
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print ("Hello, Python!")
行与缩进
缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。
if True:
print ("True")
else:
print ("False")
多行语句
Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠 \ 来实现多行语句,例如
total = item_one + \
item_two + \
item_three
如果是可迭代对象的话,一个元素输入后,不需要使用反斜杠 \ ,直接换行就好
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
数字类型
python的数字类型主要有4种
- int:整数
- float:小数,也称浮点数
- bool:布尔型
- complex:复数
字符串
字符串变量的声明
字符串变量声明的三种方式:单引号,双引号,以及三个单引号或双引号的使用。最后这种方法适用于多行显示。
-
python中单引号与双引号使用基本完全一样,但是如果是引号的嵌套,则最外层必须是双引号
-
转义符 \
-
反斜杠 \ 可以用来转义,而r可以让反斜杠不发生转义。如r"this is a line \n",则
\n
会直接显示出来。 -
字符串可以用
+
运算符连接在一起,用*
运算符重复.word = '字符串' sentence = "这是一个句子。" paragraph = """这是一个段落, 可以由多行组成""" print(word) print(sentence) print(paragraph)
字符串 这是一个句子。 这是一个段落, 可以由多行组成
其他有几个特别重点的,下面说明以下
-
字符串的索引
python的字符串索引有2种方式
从0开始以及从-1开始
重点说明:python的切片索引都是包前不包后
-
Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
paragraph = """这是一个段落, 可以由多行组成""" # 意思是从0开始,到第7个字符,步进为2 # 也就是第0,2,4,6个字符 print(paragraph[0:8:2])
这一段,
-
python的字符串是不可变类型
text = 'abcdefg' # 使用id查看变量的内存地址 print('原内存地址',hex(id(text))) text = 'abhdefg' print('修改后的内存地址',hex(id(text))) print('-'*20) l1 = list(range(0,10)) print('l1',l1) print('l1的内存',hex(id(l1))) l1[2] = 11 print('修改后内存地址',hex(id(l1)))
由下面明显可以看出内存地址改变了.字符串的内存地址改变了,但是列表的内存地址没有改变
原内存地址 0x160256cd130 修改后的内存地址 0x160253b3eb0 -------------------- l1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l1的内存 0x160256ff440 修改后内存地址 0x160256ff440
-
空行
为了增加代码的可读性,函数之间或类的方法之间会用空行进行分隔.空行与缩进不同,空行不是必须的.但是为了代码的可读性,空行还是必备的.
记住:空行也是代码的一部分
等待用户输入
执行下面的程序在按回车键后就会等待用户输入:
username = input("\n\n请输入你的名字")
print(username)
同一行使用多条语句
python默认换行就是一条新的语句.而如果不同语句想输入在同一行,则需要使用分号;
进行分隔.例如
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
多个语句构成代码组
print输出
基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
-
等号(=)用来给变量赋值。
-
等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。例如:
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
print (counter)
print (miles)
print (name)
100
1000.0
runoob
多变量赋值
python支持多变量赋值
a, b, c = 1, 2, 'runoob'
标准数据类型
python常见的数据类型有7种:(下面的括号中只是粗略的印象)
- Number(数字)
- String(字符串)
- bool(布尔)
- List(列表:一行数据)
- Tuple(元组:不可变的列表)
- Set(集合:自动去重的list)
- Dictionary(字典)
python中的可变数据与不可变数据
- 不可变数据:Number,String,Tuple
- 可变数据:list,set,dictionary
Number(数字)
python可以使用type方法查看变量的数据类型
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
python还可以使用isinstance(obj1,obj2)
的方法进行数据类型的判断.但其实isinstance是判断obj1是否是obj2的子类
# 判断a是否是int的子类
print(isinstance(a,int))
True
建立数据类型
var1 = 1
var2 = 10
数值运算
法则 | 符号 | 实例 |
---|---|---|
加法 | + | 5 + 4 |
减法 | - | 4.3 - 2 |
乘法 | * | |
除法 | / | >>> 10 / 3 3.33333… |
整除 | // | >>> 10 // 3 3 |
取余 | % | >>> 17 % 3 2 |
乘方 | ** | >>> 2 ** 5 32 |
注意:在混合乘法中,Python会把整型转换成为浮点数。
String(字符串)
字符串的截取的语法格式如下
text='abcdef'
# 变量[头下标:尾下标]
print(text[-5:-1])
bcde
一般情况下,都是正序截取
注意:与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如 word[0] = ‘m’ 会导致错误。
bool型
布尔类型即 True 或 False。
在 Python 中,True 和 False 都是关键字,表示布尔值。
List(列表)
List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下
变量[头下标:尾下标]
加号 + 是列表连接运算符,星号 ***** 是重复操作。如下实例:
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
使用切片器实现list元素的删除
a = [1, 2, 3, 4, 5, 6]
a[2:5] = [] # 将对应的元素值设置为 []
[1, 2, 6]
列表截取可以有3个参数,第三个参数是步长
List[ start : stop : step]
以下实例在索引 1 到索引 4 的位置并设置为步长为 2(间隔一个位置)来截取字符串:
逆序排列
因为列表截取有第三个参数,所以第三个参数如果是-1
,则就是逆序了.例如
定义了一个a列表,我想从最后一个元素截取到倒数第2个元素,逆序.可以这样理解,如果第三个参数是正数,则start必须小于stop.如果第三个参数是负数,则就是逆序排列,则start必须大于stop.
a = [1, 2, 3, 4, 5, 6]
print(a[-1:-3:-1])
print(a[5:3:-1])
[6,5]
[6,5]
Tuple(元组)
元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。
元组中的元素类型也可以不相同:
注意:
- 1、与字符串一样,元组的元素不能修改。
- 2、元组也可以被索引和切片,方法一样。
- 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
- 4、元组也可以使用+操作符进行拼接。
Set(集合)
Python 中的集合(Set)是一种无序、可变的数据类型,用于存储唯一的元素。
集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。
在 Python 中,集合使用大括号 {} 表示,元素之间用逗号 , 分隔。
另外,也可以使用 set() 函数创建集合。
**注意:**创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
创建格式:
parame = {value01,value02,...}
或者
set(value)
Set的集合运算
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
# 差集
print(a-b)
# 并集
print(a | b)
# 交集
print(a&b)
# 非交集
print(a ^ b)
补充:frozenset(集合)
frozenset
与set
的主要区别在于它们的可变性和哈希性。以下是具体的比较:
-
可变性:
set
是一个可变的集合类型,意味着你可以在创建之后添加、删除或修改它的元素。frozenset
是一个不可变的集合类型,一旦创建,就不能添加、删除或修改它的元素。
-
哈希性:
-
由于
frozenset
是不可变的,它是可哈希的,这意味着它可以作为字典的键或在另一个集合中作为元素。 -
相比之下,普通的
set
是不可哈希的,因此不能用作字典的键。补充:哈希性的含义:
哈希性指的是一个对象可以通过哈希函数进行哈希运算的性质。哈希函数可以将大体量数据转化为小数据,甚至仅仅是一个数字,这样可以在固定的时间复杂度下查询它。
-
-
性能:
- 在某些情况下,由于
frozenset
是可哈希的,它可能比set
更快一些,尤其是在需要哈希操作的场景中。 - 但是,如果你需要经常修改集合的内容,
set
可能会更合适,因为它是可变的。
- 在某些情况下,由于
-
使用场景:
- 当你需要一个不可变的集合对象,或者需要一个可以作为字典键的集合对象时,可以使用
frozenset
。 - 如果你需要一个可以随时更改的集合,并且不关心它是否可作为字典的键,那么使用
set
是更好的选择。
- 当你需要一个不可变的集合对象,或者需要一个可以作为字典键的集合对象时,可以使用
总的来说,选择 frozenset
还是 set
取决于你的具体需求和使用场景。如果你不需要对集合进行任何修改,并且想利用它的不可变性带来的好处(如作为字典键),那么使用 frozenset
是有意义的。否则,对于大多数情况,使用 set
是更常见的选择。
Dictionary(字典)
字典(dictionary)是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中,键(key)必须是唯一的。
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict)
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
{'one': '1 - 菜鸟教程', 2: '2 - 菜鸟工具'}
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
构造字典的方式主要有2种:
-
dict()方法:以下2种方法是一样的
dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)]) dict(Runoob=1, Google=2, Taobao=3)
-
字典推导式
{x: x**2 for x in (2, 4, 6)}
后面会有专门的推导式专题
Python数据类型转换
常见的数据类型转换
下面罗列几个常用的数据类型转换 的方法
函数 | 描述 |
---|---|
int(x ,base]) | 将x转换为一个整数 |
float(x) | 将x转换到一个浮点数 |
str(x) | 将对象 x 转换为字符串 |
tuple(x) | 将序列 s 转换为一个元组 |
list(x) | 将序列 s 转换为一个列表 |
set(x) | 转换为可变集合 |
dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
隐式数据类型转换
在隐式类型转换中,Python 会自动将一种数据类型转换为另一种数据类型,不需要我们去干预。
以下实例中,我们对两种不同类型的数据进行运算,较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失。
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo
print("num_int 数据类型为:",type(num_int))
print("num_flo 数据类型为:",type(num_flo))
print("num_new 值为:",num_new)
print("num_new 数据类型为:",type(num_new))
num_int 数据类型为: <class 'int'>
num_flo 数据类型为: <class 'float'>
num_new: 值为: 124.23
num_new 数据类型为: <class 'float'>
注意:文本型的数字不能与整型、浮点型进行运算,否则会报错
因为比如加法,在文本型中他指的是字符串之间的联接,而数值型指的是加法。2个的运算方式完全不同,因此文本型与数值型不能进行运算。
运算符
- 算术运算符
- 比较(关系)运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 运算符优先级
算数运算符
比较运算符
注意:不等于的表示方法是!=
赋值运算符
-
普通的赋值运算就是
=
-
其他的就是四则赋值运算符
运算符 描述 实例 += 加法赋值运算符 c += a 等价于 c = c + a -= 减法赋值运算符 *= 乘法赋值运算符 /= 除法赋值运算符 %= 取余赋值运算符 **= 乘方赋值运算符 //= 取整除法赋值运算符
位运算符
位运算符主要是进制运算,这里就暂时不介绍了
逻辑运算符
运算符 | 逻辑表达式 |
---|---|
and | x and y |
or | x or y |
not | not x |
注意:python中,如果变量为0或者为null,None,都是false
成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 | 描述 |
---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False。 |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False。 |
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
# in的说明
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
# not in的说明
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中")
else:
print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")
身份运算符
身份运算符用于比较两个对象的存储单元
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y , 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
注意:is 和 == 是不一样的。is是判断二者的引用是否为同一个。而==是判断二者的值是否相同
运算符的优先级
可以参考数学的运算符优先级。一般情况下,可以活用( )
数字类型
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
数学函数
函数 | 返回值 ( 描述 ) |
---|---|
abs(x) | 返回数字的绝对值,如abs(-10) 返回 10 |
ceil(x) | 返回数字的上入整数,如math.ceil(4.1) 返回 5 |
exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
fabs(x) | 以浮点数形式返回数字的绝对值,如math.fabs(-10) 返回10.0 |
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的平方根。 |
注意:fabs与modf需要导入math模块
随机数函数
随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
以下所有的函数都需要提前导入random包
函数 | 描述 |
---|---|
choice(seq) | 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 |
randrange ([start,] stop [,step]) | 从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1 |
random() | 随机生成下一个实数,它在[0,1)范围内。这是一个无参数 |
seed() | 设置随机数种子 |
shuffle(lst) | 将序列进行洗牌排序 |
uniform(x,y) | 随机生成一个实数,在x,y之间 |
三角函数
数学常量
常量 | 描述 |
---|---|
pi | 圆周率 |
e | 自然常数 |
字符串
字符串更新
你可以截取字符串的一部分并与其他字段拼接,如下实例:
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')
Hello Runoob!
转义字符
在需要在字符中使用特殊字符时,python 用反斜杠 \ 转义字符。如下表:
转义字符 | 描述 | 实例 |
---|---|---|
\(在行尾时) | 续行符 | >>> print(“line1 \ … line2 \ … line3”) line1 line2 line3 >>> |
\\ | 输入\时 | |
\’ | 输入’时 | |
\" | 输入"时 | |
\a | 响铃.执行后电脑有响声。 | |
\n | 换行 | |
\t | 横向制表符 | |
\v | 纵向制表符 | >>> print(“Hello \v World!”) Hello World! >>> |
print输入小数点后2位的方法
字符串运算符
操作符 | 描述 |
---|---|
+ | 字符串连接 |
* | 重复输出字符串 |
in | 成员运算符 - 如果字符串中包含给定的字符返回 True |
not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True |
r | 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 |
% | 格式字符串(看下一节) |
字符串格式化
使用百分号%
Python 支持格式化字符串的输出 。
尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!
输出2位小数的方法
print('%.2f' % 10)
10.00
说明:前面’ {} '.format(变量)的形式,花括号中要使用冒号。冒号或者百分号可以理解为占位符
‘string{变量名}’.format()的方法
n1 = 10.111111
n2 = 0.1532
print("{:.2f}".format(n1))
print("{:.2%}".format(n2))
f ’ string ’
f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。
name = 'Runoob'
print(f'hello {name}')
print(f'1+2 = {1+2}')
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f"name:{w['name']},url:{w['url']}")
hello Runoob
1+2 = 3
name:Runoob,url:www.runoob.com
字符串的内置函数
下面的所有函数都是字符串对象的方法,使用的方法都是Strobj.func()
,如第一个就是Strobj.capitalize()
函数 | 简述 | 描述 |
---|---|---|
capitalize() | 首字母 | |
title() | ||
center(width,fillchar) | 指定的宽度 width 居中的字符串 | fillchar为填充字符,默认为空格 |
count(str,start=0,end=len(string)) | 返回str在string中出现的次数 | start与end如果指定的话,则是返回固定范围内出现的次数 |
endswith(suffix,start,end=len(string)) | 检查字符串是否是suffix结束 | |
find(suffix,start,end=len(string)) | 检测str是否在字符串中.如果找到返回index如果没有找到,则返回-1 | >>> name = ‘mutong’ name.find(‘a’) >>> -1 |
rfind(suffix,start,end=len(string)) | 类似于find,只不过是从右边开始找 | |
index(suffix,start,end=len(string)) | 跟find()方法一样,只不过如果str不在字符串中会报一个异常。 | |
isalum() | 检测字符串是否由字母和数字组成 | 注意:如果字符串中由汉字也返回True |
isdigit() | 检测字符串是否由数字组成 | |
isnumeric() | 如果字符串中只包含数字字符,则返回 True,否则返回 False | 它与isdigit的区别是:数字并不是只有阿拉伯数字,比如中文的一二三也是数字.isdigit是判断是否是阿拉伯数字.而isnumeric对中文的一二三也可以识别为数字 |
islower() | 检测是否都是小写 | |
isupper() | 检测是否都是大写 | |
join(seq) | 使用指定的字符,将seq链接为字符串 | >>> s1 = ‘-’ s1.join((“r”, “u”, “n”, “o”, “o”, “b”)) >>> ‘r-u-n-o-o-b’ |
len(str) | 统计字符个数 | |
lower() | 转换为小写 | |
upper() | 转换为大写 | |
lstrip([chars]) | 截掉字符串左边的空格或指定字符。 chars默认为空格 | >>> str = " this is string example…wow!!! "; this is string example…wow!!! >>> str = “88888888this is string example…wow!!!8888888”; this is string example…wow!!!8888888 |
rstrip([chars]) | 截掉字符串右边的空格或指定字符 | |
strip([chars]) | 同时执行lstrip与rstrip | |
replace(old,new,[max]) | 把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。 | |
str.split(str=“”, num=string.count(str)) | str – 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等 num – 分割次数,如果设置了这个参数,则最多分割成 maxsplit+1 个子字符串。默认为 -1, 即分隔所有。 | >>> str = “this is string example…wow!!!” print (str.split()) # 默认以空格为分隔符 print (str.split(‘i’,1)) # 以 i 为分隔符 print (str.split(‘w’)) # 以 w 为分隔符 [‘this’, ‘is’, ‘string’, ‘example…wow!!!’] [‘th’, ‘s is string example…wow!!!’] [‘this is string example…’, ‘o’, ‘!!!’] |
列表
序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值,称之为索引,第一个索引是 0,第二个索引是 1,依此类推。
访问列表中的值
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
red
green
blue
具体的列表的切片与索引,可详见2.6 List列表
修改列表内元素
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
第三个元素为 : 1997
更新后的第三个元素为 : 2001
列表中追加元素
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
删除列表元素
使用del 删除列表元素
list = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
原始列表 : ['Google', 'Runoob', 1997, 2000]
删除第三个元素 : ['Google', 'Runoob', 2000]
列表脚本操作符
Python表达式 | 结果 | 描述 |
---|---|---|
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, end=" ") | 1 2 3 | 迭代 |
嵌套列表
使用嵌套列表即在列表里创建其他列表,例如:
n = ['a','b','c']
a = list(range(3))
x = [n,a]
print(x)
print(x[0][1])
[['a', 'b', 'c'], [0, 1, 2]]
'b'
列表比较
列表比较需要引入 operator 模块的 eq 方法(详见:Python operator 模块):
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
Python列表函数&方法
Python包含以下函数:
函数 | 描述 |
---|---|
len(list) | 列表元素个数 |
max(list) | 返回列表元素最大值 |
min(list) | 最小值 |
list(seq) | 将seq转为列表 |
Python包含以下方法
函数 | 描述 |
---|---|
list.append(obj) | 末尾添加新的对象 |
list.insert(index,obj) | 在指定位置插入新对象 |
list.pop([index=-1]) | 移除指定位置的对象,并返回移除的对象。默认为-1(最后一个) |
list.remove(obj) | 移除列表中某个值的第一个匹配项 |
list.count(obj) | 统计obj在list中出现的次数 |
list.extend(seq) | 扩展:在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
list.reverse() | 反向列表中元素 |
list.sort( key=None, reverse=False) | 对原列表继续排序。reverse是正序或逆序。 |
list.clear() | |
list.copy() | 复制,详见如下 |
注意:copy与=
不一样。赋值是直接将内存地址进行赋值。而复制时重新开辟一个内存地址。赋值如果a=b,如果对b进行修改,则a也进行修改。这点一定要注意
a = ['a','b','c']
b = a
print(b)
a[2]='d'
print(b)
['a', 'b', 'c']
['a', 'b', 'd']
a = ['a','b','c']
b = a.copy()
print(b)
a[2]='jj'
print(a)
print(b)
['a', 'b', 'c']
['a', 'b', 'jj']
['a', 'b', 'c']
元组
Python 的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号 ( ),列表使用方括号 [ ]。
元组的创建
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
# 不需要括号也可以,不推荐
tup3 = "a", "b", "c", "d"
创建空元组
tup1=()
注意:元组中只包含一个元素时,需要在元素后面添加逗号 ,否则括号会被当作运算符使用:
>>> tup1 = (50)
>>> type(tup1) # 不加逗号,类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号,类型为元组
<class 'tuple'>
访问元组
与字符串,列表的切片器一样
修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,元组的连接还是使用+
号。
删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup
元组运算符
表达式 | 描述 |
---|---|
len(tup) | 元组内元素的个数 |
+ | 元组联接 >>> a = (1,2,3) >>> b =(4,5,6) >>> c=a+b (1,2,3,4,5,6) |
+= | 元组联接 >>> a += b |
* | 重复 |
in | 元素是否存在 |
for x in (1,2,3):print(i) | 迭代 |
元组内置函数
方法 | 描述 |
---|---|
len(tuple) | 计算元组内元素个数 |
max(tuple) | 求最大值 |
min(tuple) | 求最小值 |
tuple(iterable) | 将可迭代对象转为元组 |
字典
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:
d = {key1 : value1, key2 : value2, key3 : value3 }
注意:dict
作为 Python 的关键字和内置函数,变量名不建议命名为 dict。
键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字。
tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
创建空字典
- 使用大括号
{ }
创建空字典
# 使用大括号 {} 来创建空字典
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))
{}
Length: 0
<class 'dict'>
- 使用内置函数创建字典
emptyDict = dict()
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:",len(emptyDict))
# 查看类型
print(type(emptyDict))
{}
Length: 0
<class 'dict'>
访问字典里的值
把相应的键放入到方括号中,如下实例:
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
tinydict['Name']: Runoob
tinydict['Age']: 7
如果字典里没有的键访问数据,则会报KeyError
的错误
修改字典
字典的修改是追加新的键值对或者更改键对应的值
追加新的键值对以及修改
直接对针对字典的键进行赋值
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典,清空只需一项操作。
显式删除一个字典用del命令,如下实例:
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
字典键的特性
- 字典的键必须具有 唯一性,同一个键被赋值2次,则会记住最后一次
- 字典的键必须是不变类型,因此字符串,数字,元组均可以。但是列表,集合不行
字典的内置函数&方法
函数 | 描述 | 实例 |
---|---|---|
dict1.clear() | ||
dict1.copy() | ||
dict1.fromkeys(seq,[value]) | 以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。 | >>> seq = [‘a’,‘b’,‘c’] >>> tinydict = dict.fromkeys(seq, 10) |
dict1.update(dict2) | 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。相当于字典的拼接 | |
dict1.get(key,default=None) | 返回指定键的值,如果键不在字典中返回 default 设置的默认值 | |
dict1.setdefault(key,default=None) | 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default | |
key in dict1 | 判断key是否在dict中 | |
dict1.items() | 获取字典的所有键值对,返回的是一个dict_items的对象,里面是类似于列表的形式,见右边 | >>> tinydict.items() dict_items([(‘a’, 20), (‘b’, 10), (‘c’, 10)]) |
dict1.keys() | 获取字典的所有键,返回的是dict_keys的对象,里面类似于列表形式 | |
dict1.values() | 获取字典的所有键,返回的是dict_values的对象,里面类似于列表形式 | |
dict1.pop(key,[defult]) | 字典 pop() 方法删除字典 key(键)所对应的值,返回被删除的值。 1. 如果 key 存在 - 删除字典中对应的元素2. 如果 key 不存在 - 返回设置指定的默认值 default 3. 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常 | |
dict1.popitem() | 删除字典的最后一个键值对,如果字典为空,就会显示KeyError的错误 |
集合
集合(set)是一个无序的不重复元素序列。
集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合,元素之间用逗号 , 分隔, 或者也可以使用 set() 函数创建集合。
parame = {value01,value02,...}
或者
set(value)
**注意:**使用set()创建集合的时候,里面只能由一个元素,如下
# 如果set里面只有一个括号,会报错:TypeError: set expected at most 1 argument, got 3
thisset = set(("Google", "Runoob", "Taobao"))
**注意:**创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
添加元素
s.add( x )
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
添加元素还有update的方法,update相当于将添加的可迭代元素进行拆包后,再添加。update与add的区别详见如下:
thisset = set(["Google", "Runoob", "Taobao"])
thisset.add(('a','b'))
thisset
{('a', 'b'), 'Google', 'Runoob', 'Taobao'}
thisset = set(["Google", "Runoob", "Taobao"])
thisset.update(('a','b'))
thisset
{'Google', 'Runoob', 'Taobao', 'a', 'b'}
移除元素
- remove
语法如下:
s.remove( x )
实例如下
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
- discard
还有另外一种方法是discard,它与remove的区别是,如果对应的元素没有,不会报错
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook") # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
-
pop
我们也可以设置随机删除集合中的一个元素,返回被删除的元素。语法格式如下:
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
Runoob
计算集合内元素个数
语法如下
len(s)
清空集合
语法如下
s.clear()
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
判断语法是否在集合中
语法格式如下:
x in s
集合的运算
a = set('abcdefg')
b = set('efghijk')
运算 | 简述 | 结果 |
---|---|---|
a - b | 包含于集合a,不包含于集合b | {‘a’, ‘b’, ‘c’, ‘d’} |
a | b | 并集 | {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’} |
a & b | 交集 | {‘e’, ‘f’, ‘g’} |
a ^ b | 非交集 | {‘a’, ‘b’, ‘c’, ‘d’, ‘h’, ‘i’, ‘j’, ‘k’} |
集合内置方法完整列表
方法 | 描述 |
---|---|
add() | 添加元素 |
update() | 拆包后添加元素 |
clear() | 集合清空 |
copy() | 复制 |
discard() | 删除指定元素,不会报错 |
remove() | 删除指定元素,如果没有会报错 |
pop() | 随机删除元素,没有会报错 |