Python基础教程1

基础教程

基础语法

标识符

标识符的定义

标识符（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)
  

  字符串
  这是一个句子。
  这是一个段落，
  可以由多行组成
  

  其他有几个特别重点的,下面说明以下

  1. 字符串的索引

     python的字符串索引有2种方式

     从0开始以及从-1开始

     重点说明:python的切片索引都是包前不包后

  2. Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

     paragraph = """这是一个段落，
     可以由多行组成"""
     
     # 意思是从0开始,到第7个字符,步进为2
     # 也就是第0,2,4,6个字符
     print(paragraph[0:8:2])
     

     这一段，
     

  3. 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种:(下面的括号中只是粗略的印象)

1. Number(数字)
2. String(字符串)
3. bool(布尔)
4. List(列表:一行数据)
5. Tuple(元组:不可变的列表)
6. Set(集合:自动去重的list)
7. 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的主要区别在于它们的可变性和哈希性。以下是具体的比较：

1. 可变性：

   • set 是一个可变的集合类型，意味着你可以在创建之后添加、删除或修改它的元素。
   • frozenset 是一个不可变的集合类型，一旦创建，就不能添加、删除或修改它的元素。

2. 哈希性：

   • 由于 frozenset 是不可变的，它是可哈希的，这意味着它可以作为字典的键或在另一个集合中作为元素。

   • 相比之下，普通的 set 是不可哈希的，因此不能用作字典的键。

     补充：哈希性的含义：

     哈希性指的是一个对象可以通过哈希函数进行哈希运算的性质。哈希函数可以将大体量数据转化为小数据，甚至仅仅是一个数字，这样可以在固定的时间复杂度下查询它。

3. 性能：

   • 在某些情况下，由于 frozenset 是可哈希的，它可能比 set 更快一些，尤其是在需要哈希操作的场景中。
   • 但是，如果你需要经常修改集合的内容，set 可能会更合适，因为它是可变的。

4. 使用场景：

   • 当你需要一个不可变的集合对象，或者需要一个可以作为字典键的集合对象时，可以使用 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种:

1. dict()方法:以下2种方法是一样的

   dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
   dict(Runoob=1, Google=2, Taobao=3)
   

2. 字典推导式

   {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个的运算方式完全不同，因此文本型与数值型不能进行运算。

运算符

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

算数运算符

详见基本数据类型 --> Nunber --> 数值运算 

比较运算符

注意：不等于的表示方法是!=

赋值运算符

• 普通的赋值运算就是=

• 其他的就是四则赋值运算符

  运算符	描述	实例
  +=	加法赋值运算符	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         # 删除字典

字典键的特性

1. 字典的键必须具有 唯一性，同一个键被赋值2次，则会记住最后一次
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()	随机删除元素，没有会报错