Python 学习笔记（1）

目录

print函数

 input函数

Python注释

变量名

变量赋值

字符串

数字类型

 逻辑运算

短路逻辑和运算符的优先级

if语句的语法结构

1.判断一个条件，若该条件成立，就执行其包含的语句或代码块。

2.判断一个条件：

如果条件成立，执行其包含的语句或代码块；如果条件不成立，执行另外的包含的语句或代码块。

3.判断多个条件：若第一个条件不成立，则判断第二个条件；若第二个不成立，则判断第三个，以此类推。若条件成立则执行其包含的语句或代码块。

4、在第三种情况下，加上else，表示以上所有条件不成立时，执行其包含语句或代码。

5.条件表达式

条件成立执行时的语句 if 条件 条件不成立执行的语句，相当于2.if...else.

循环结构

while循环

for循环

break

continue

else

当循环条件不为真时，会执行else包含的语句或代码块。可以作为循环结束的标志。

列表

创建列表

访问列表中的元素

切片

增（添加列表的元素）

删（删除列表元素）

改（更新列表）

列表的加法（拼接）和乘法（重复列表的元素）

嵌套列表

查（查找元素或下标）

 列表-表格：

列表推导式

print函数

用于打印输出一个对象。（概念知识来自鱼C论坛和菜鸟教程）

print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)

>>> print(12,45,56,sep='+',end='?')
12+45+56?

参数	含义
objects	指定待输出的对象，多个对象之间使用英文逗号（,）进行分隔
sep	指定输出多个对象之间的分隔符，默认是空格（' '）
end	指定最后的结束符，默认是换行符（'n'）

 input函数

input() 函数从标准输入流中读取一行数据，将其转换为字符串（末尾的换行符将被舍弃）后并返回。

>>> temp=input("你的名字是什么？")
你的名字是什么？bbb
>>> 

>>> temp
'bbb'
>>> 

Python注释

>>> """
这是多行使用的注释
这是多行使用的注释
这是多行使用的注释
	"""

#这是单行用的注释

变量名

通常使用字母，数字和下划线组成，但不能由数字开头。

 python3可以使用中文作为变量名

>>> 早=1
>>> 早
1
>>> 

变量被赋值后才能使用，否则会报错。

>>> print(y)
Traceback (most recent call last):
  File "", line 1, in 
    print(y)
NameError: name 'y' is not defined

变量赋值

运算符”=“ 例子：

>>> x=4 #单个变量
>>> y=a=5#多个变量
>>> print(x,y,a)
4 5 5
>>> 

#使用中间变量交换两变量的值
>>> z=x
>>> x=y
>>> y=z
>>> print(x,y,z)
5 4 4
>>> 

字符串

字符串用来表示文本序列。例子：

>>> print("hfwo")
hfwo
>>> print('fhs')
fhs

长字符串的表示

 使用三个单引号或双引号

a='''
hfweofij
vjpaergov
'''
b="""
fjwpaorgvbik[r
vjc[roawf
fjk[w
"""
print(a,b)

有时会遇到报错的情况： 

>>> print('Let's go!')
	  
SyntaxError: invalid syntax

使用转义字符""或”“可以解决问题 

>>> print("Let's go!")
	  
Let's go!
>>> print('Let's go!')
	  
Let's go!

 加r时，转义字符不起作用。 

>>> print(r'Let's go!')
	  
Let's go!

>>> print("D:dgfervd")
	  
D:dgferd
>>> print(r"D:dgfervd")
	  
D:dgfervd

字符串拼接

重复输出字符串

>>> print("dhwkl"+"cjhndi")
    
dhwklcjhndi
>>> print("cjhdspa"*2)
    
cjhdspacjhdspa
>>> 

数字类型

整数

长度不受限制。

浮点数

小数,并不精确。

>>> a=0.1
    
>>> b=0.2
    
>>> print(a+b)
    
0.30000000000000004

 可以使用decimal解决。

import decimal
    
>>> a=decimal.Decimal("0.1")
    
>>> b=decimal.Decimal("0.2")
    
>>> print(a+b)
    
0.3
>>> 

科学计数法

>>> print(0.000000005,-0.0000004)
    
5e-09 -4e-07

复数 

形如a+bj，以浮点数存放。

数字运算

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

abs	取绝对值	abs(-2) 输出结果 2
int	取整数	in(3.5) 输出结果 3
float	取浮点数	float（52） 输出结果 52.0
pow	计算x的y次方	pow(2,4) 输出结果16

易错点：

// 不是将小数部分完全抹去。

 补充：

pow(x,y,z)存在三个参数时‘

pow(2,3,5)  先做幂运算在做求余运算。（2**3）%5

布尔类型

bool() 判断（）内的真假。分支语句和循环语句都需要判断条件的真假

常见为假的数据

1.定义为False的对象：None和False

2.值为0的数字类型:0,0.0,0j,Decimal()

3.表示空的序列和集合：'',[],(),range(0),{},set()

>>> bool(None)
    
False
>>> bool(False)
    
False
>>> bool(0)
    
False
>>> bool(0.0)
    
False
>>> bool('')
    
False
>>> bool([])
    
False

记得要先引入模块 ：

>>> bool(decimal(0))
    
Traceback (most recent call last):
  File "", line 1, in 
    bool(decimal(0))
TypeError: 'module' object is not callable
>>> import decimal
    
>>> bool(decimal.Decimal(0))
    
False

 逻辑运算

由于逻辑运算的运算对象时布尔数据，逻辑运算也叫布尔运算。

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

例子：

>>> 3 or 0
    
3
>>> 0 or 4
    
4
>>> 8>5 and 4<5
    
True
>>> not 1
    
False
>>>

短路逻辑和运算符的优先级

短路逻辑：只有当第一个操作数无法确定逻辑运算的结果时，才对第二个操作数进行求值。

例子：

>>> (not 1)or(3 and 4)or(5 and 9) 
   #   0   or   4 
   #     4
    
4

乘除取余地板除（//）优先级大于加减大于比较运算符（>,<,==)not 大于and大于or

>>> not 1 or 3 and 4 or 5 and 9
    
4

>>> not 0>4
    
True
>>> 1+2>3-1
    
True

if语句的语法结构

1.判断一个条件，若该条件成立，就执行其包含的语句或代码块。

if 3<0:
    print("c")
    print('cf')

结果：c

           cf 

2.判断一个条件：

如果条件成立，执行其包含的语句或代码块；如果条件不成立，执行另外的包含的语句或代码块。

if 3:
    print(1)
else:
    print(2)

结果：1

3.判断多个条件：若第一个条件不成立，则判断第二个条件；若第二个不成立，则判断第三个，以此类推。若条件成立则执行其包含的语句或代码块。

score=input("请输入你的成绩")
score=int(score)
if 0<=score<60:
    print("D")
if 60<=score<80:
    print("C")
if 80<=score<90:
    print("B")
if 90<=score<=100:
    print("A")

结果：请输入你的成绩89
           B

score=input("请输入你的成绩")
score=int(score)
if 0<=score<60:
    print("D")
elif 60<=score<80:
    print("C")
elif 80<=score<90:
    print("B")
elif 90<=score<=100:
    print("A")

第二种方式进程更快。

假设某个条件成立，执行其包含的语句或代码块后直接跳出循环，效率高。

4、在第三种情况下，加上else，表示以上所有条件不成立时，执行其包含语句或代码。

score=input("请输入你的成绩")
score=int(score)
if 0<=score<60:
    print("D")
elif 60<=score<80:
    print("C")
elif 80<=score<90:
    print("B")
elif 90<=score<=100:
    print("A")
else:
    print("您输入的数据有误。")

结果：请输入你的成绩680
           您输入的数据有误。

5.条件表达式

条件成立执行时的语句 if 条件 条件不成立执行的语句，相当于2.if...else.

a=4
b=5
small=a if a 
结果：4
 
循环结构 
while循环 
当条件成立，其包含的语句或代码块就会一直被执行。
 
i=1
sum=0
while i<=100:
    sum+=i
    i+=1
print(sum)
 
结果：5050 
 
出现死循环（条件恒为真），按ctrl+c退出。
 
for循环 
结构：
 
for 变量 in 可迭代的对象：
 
        语句或代码块
 
可迭代对象：元素能单独被提取出来的对象（比如字符串，range()）
 
从字符串"abcdef"中依次拿出a,b,c,d,e,f各个元素的过程为迭代。
 
>>> for n in "abcdef":
        print(n)

    
a
b
c
d
e
f
 
转化成while 
 
>>> i=0
>>> while i < len("abcdef"):
	print("abcdef"[i])
	i+=1

	
a
b
c
d
e
f
 
补充：
 
len函数表示字符串的长度 
 
 
 累加问题
 
>>> for i in range(101):
	sum+=i

	
>>> print(i)
100
>>> print(sum)
5050
>>> 
 
 
break 
可以退出循环体。
 
'''查找素数'''

for n in range(2,10):
    for i in range(2,n):
        
        if n%i==0:
            
            break
    else:
        print(n,"是素数")
 
补充：
 
range(10)表示[0,10)的数字序列
 
range(1,10)表示[1,10)的数字序列
 
range(1,10,2)
 
[ 1,10,2] 表示[1，3，5，7，9]
 
在[1,10)范围内，以2为间隔，依序输出数字。
 
continue 
跳出本次循环，直接执行下一次循环。
 
>>> i=1
    while i<10:
    i+=1
    if i%2==0:
          continue
    print(i)

    
1
3
5
7
9
 
else 
当循环条件不为真时，会执行else包含的语句或代码块。可以作为循环结束的标志。 
for n in range(2,10):
    for i in range(2,n):
        
        if n%i==0:
            
            break
    else:
        print(n,"是素数")
 
比如：n为4，i为2时：n%i==0为真，跳出循环。此时 for i in range(2,n)循环未结束，不执行print语句。
 
列表 
创建列表 
创建一个列表，只要把逗号分隔的不同的数据项使用方括号[]括起来即可。
 
>>> rhy=["hfsiol",1,2,9,"f"]
>>> rhy
['hfsiol', 1, 2, 9, 'f']
 
访问列表中的元素 
>>> rhy[0]
'hfsiol'
>>> rhy[5]
Traceback (most recent call last):
  File "", line 1, in 
    rhy[5]
IndexError: list index out of range
>>> 
 
列表中的每个元素都分配一个数字 - 它的位置，或索引（下标），第一个索引（下标）是0，第二个索引（下标）是1，依此类推，list index out of range超出了列表的索引。
 
访问未知长度的列表的最后一个元素
 
>>> rhy[-1]
'f'
 
最后一个元素的索引值可以是-1，倒数第二个可以是-2，以此类推。
 
切片 
使用切片可以截取列表中的元素。
 
rhy[起：终：间隔]
 
间隔值为负数表示倒序。
 
>>> rhy=["hfsiol",1,2,9,"f"]
>>> rhy[:3]
['hfsiol', 1, 2]
>>> rhy[0:3]
['hfsiol', 1, 2]
>>> rhy[1:3]
[1, 2]
>>> rhy[::2]
['hfsiol', 2, 'f']
>>> rhy[::-2]
['f', 2, 'hfsiol']
 
补充：Python为什么使用从0开始的列表索引方式？
 
假设从1开始：使用切片语法时，为了从第 i 位索引开始取后 n 个元素，你就得把表达式写成 a[i：i+n-1]；
 
而从0开始：使用切片语法时，为了从第 i 位索引开始取后 n 个元素，表达式写成 a[i：i+n]。看起来十分简洁和优雅。
 
增（添加列表的元素） 
1.在原列表最后一个元素后面添加
 
append（）只能添加一个元素，添加的新元素会补充到原列表的最后一个元素后面。
 
>>> list=[]
>>> list.append('append')
>>> print(list)
['append']
 
 使用切片：
 
>>> s=[]
>>> s[len(s):]='append'
>>> s
['a', 'p', 'p', 'e', 'n', 'd']
 
 
extend（）可以添加一个可迭代的对象，添加的新内容会补充到原列表最后一个元素的后面。
 
>>> list=[]
>>> list.append('append')
>>> print(list)
['append']
>>> list.extend([1,4,6,'白雪','Good'])
>>> list
['append', 1, 4, 6, '白雪', 'Good']
 
使用切片：
 
>>> a=[1,2,3]
>>> a[len(a):]=[4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
 
2.在任意的位置添加一个新元素
 
insert()在任意位置添加一个新元素。
 
a.insert(下标，添加新元素)
 
>>> a=[1,2,3,4,5,6]
>>> a.insert(1,2)
>>> a
[1, 2, 2, 3, 4, 5, 6]
>>> a.insert(3,6)
>>> a
[1, 2, 2, 6, 3, 4, 5, 6]
>>> 
 
删（删除列表元素） 
1.删除一个指定元素
 
remove（）可以将指定的元素删除。如果有多个元素重复，则只会删除下标最小的元素。
 
>>> a
[1, 2, 2, 6, 3, 4, 5, 6]
>>> a.remove(6)
>>> a
[1, 2, 2, 3, 4, 5, 6]
 
如果指定元素不存在，会报错 x not in list
 
>>> a
[1, 2, 2, 3, 4, 5, 6]
>>> a.remove(0)
Traceback (most recent call last):
  File "", line 1, in 
    a.remove(0)
ValueError: list.remove(x): x not in list
 
2.删除一个指定下标的元素。
 
pop()
 
>>> a
[1, 2, 2, 3, 4, 5, 6]
>>> a.pop(0)
1
>>> a
[2, 2, 3, 4, 5, 6]
 
3.清空所有的元素
 
clear（）
 
>>> a.clear()
>>> a
[]
 
改（更新列表） 
列表是可变的，字符串是不可变的。（列表可以直接用赋值运算符更改新的值）
 
补充：
 
可变不可变指的是内存中的值是否可以被改变，
 
不可变类型指的是对象所在内存块里面的值不可以改变，有数值、字符串、元组；
 
可变类型则是可以改变，主要有列表、字典。
 
>>> b=['a','b','c','d']
>>> b[1]=9
>>> b
['a', 9, 'c', 'd']
>>> b[:3]=[2,3.5]
>>> b
[2, 3.5, 'd']
 
排序
 
sort() 将数字从小到大进行排序。
 
>>> d=[2.3,0.1,4,5,2,3]
>>> d.sort()
>>> d
[0.1, 2, 2.3, 3, 4, 5]
 
reverse（）倒序按元素下标倒着输出 。
 
>>> d=[2.3,0.1,4,5,2,3]
>>> d.reverse()
>>> d
[3, 2, 5, 4, 0.1, 2.3]
>>> d.sort(reverse=True)
>>> d
[5, 4, 3, 2.3, 2, 0.1]
>>> 
 
 
列表的加法（拼接）和乘法（重复列表的元素） 
 例子：
 
>>> s=[1,2,3]
>>> t=[4,5,6]
>>> s+t
[1, 2, 3, 4, 5, 6]
>>> t*3
[4, 5, 6, 4, 5, 6, 4, 5, 6]
 
嵌套列表 
列表里面包含列表。
 
创建二维列表：
 
1.直接赋值
 
>>> matrix=[[1,2,3],[4,5,6],[7,8,9]]
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
 2.先创建一维列表，再使用循环结构创建并对其进行初始化
 
>>> k=[0]*3
>>> k
[0, 0, 0]
>>> for i in range(3):
	k[i]=[0]*3

	
>>> k
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
 
实质上是把a里面原先的三个元素给替换掉。 
 
>>> for i in range(2):
	k[i]=[0]*3

	
>>> k
[[0, 0, 0], [0, 0, 0], 0]
 
 访问嵌套列表
 
>>> matrix[0]
[1, 2, 3]
>>> matrix[2][0]
7
 
接下来看一下这一段代码：
 
为什么修改列表m后，结果很奇怪 .
 
>>> k=[0]*3
>>> k
[0, 0, 0]
>>> for i in range(3):
	k[i]=[0]*3

	
>>> k
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> m=[[0]*3]*3
>>> m
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> k[1][1]=3
>>> k
[[0, 0, 0], [0, 3, 0], [0, 0, 0]]
>>> m[1][1]=3
>>> m
[[0, 3, 0], [0, 3, 0], [0, 3, 0]]
>>> 
 
 解释：
 
引入一个新知识;
 
is运算符:判断两个变量是否指向同一个对象(两个变量是否指向同一个存储空间)，若指向同一个则返回True, 反之则返回False.
 
>>> k[1] is k[2]
False
>>> m[1] is m[2]
True
 
 m=[[0]*3]*3拷贝了对[0,0,0]一维列表的引用，指向同一个存储空间，相互影响；k中一维列表的存储空间不同，相互独立。
 
前面有提到可变性和不可变性，对于内存值可变的列表和字典，即使数据相同，都会开辟独立的存储空间；对于内存值不可变的数字，字符串和元组，相同数据用同一个存储空间。
 
可以用is来证明：
 
>>> x=[1,2,3]
>>> y=[4,5,6]
>>> x is y
False
>>> x=1
>>> y=1
>>> x is y
True
 
查（查找元素或下标） 
1.查找元素出现的次数
 
count(要查找的元素)
 
2.查找某个元素的索引（下标）值
 
index(要查找的元素)
 
 index(要查找的元素，起，终)      有多个重复元素时，只能找到下标最小的。
 
>>> c=[2,3,2,1,6,9,3,5,6,10]
>>> c.count(6)
2
>>> c.index(0)
Traceback (most recent call last):
  File "", line 1, in 
    c.index(0)
ValueError: 0 is not in list
>>> c.index(6)
4
>>> c.index(6,5,9)
8
 
 3.拷贝
 
浅拷贝
 
3.1对列表整体进行拷贝copy()
 
>>> c=[2, 3, 2, 1, 6, 9, 3, 5, 6, 10]
>>> m=c.copy()
>>> m
[2, 3, 2, 1, 6, 9, 3, 5, 6, 10]
>>> 
 
3.2.切片可以任意截取位置进行拷贝
 
>>> c=[2, 3, 2, 1, 6, 9, 3, 5, 6, 10]
>>> t=c[:]
>>> t
[2, 3, 2, 1, 6, 9, 3, 5, 6, 10]
>>> h=c[3:]
>>> h
[1, 6, 9, 3, 5, 6, 10] #部分拷贝
>>> 
 
前面提到的拷贝：拷贝的是整个列表对象，而不仅仅是对其的引用。
 
可以用is来证明：
 
​
>>> x=[1,2,3]
>>> y=x.copy()
>>> x is y
False
>>> 

​
 
>>> m=[4,5,6]
>>> n=m[:]
>>> n
[4, 5, 6]
>>> m is n
False
 
但是浅拷贝只能解决一维列表的问题，在二维列表中会出错。
 
>>> a=[[1,4,5],[5,7,9]]
>>> b=a.copy()
>>> a[0][2]=10
>>> a
[[1, 4, 10], [5, 7, 9]]
>>> b
[[1, 4, 10], [5, 7, 9]]
>>> a is b
False
>>> a[0] is b[0]
True
>>> a[1] is b[1]
True
 
可以从代码中看出：浅拷贝拷贝了外层的对象，和内层对象的引用。
 
深拷贝 
 
 深拷贝可以解决这个问题：即使存在多层嵌套也可以全方位拷贝。
 
>>> import copy
>>> x=[[1,2,3],[4,5,6],[7,8,9]]
>>> y=copy.deepcopy(x)
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> x[1][1]=10
>>> x
[[1, 2, 3], [4, 10, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> x[2] is y[2]
False
 
 图解：（例子来自菜鸟教程）
 
b = a: 赋值引用，a 和 b 都指向同一个对象。
 
 
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
 
 
b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
 
 
 列表-表格： 
方法
含义
s.append(x)
将 x 元素添加到 s 列表的末尾，相当于 s[len(s):] = [x]
s.extend(iterable)
将可迭代对象中的每个元素依次添加到 s 列表的末尾，相当于 s[len(s):] = iterable
s.insert(i, x)
将 x 元素插入到 s 列表中的 i 位置（其它元素依次往后递推）。所以，s.insert(0, x) 是将 x 元素插入到 s 列表的开头；s.insert(len(s), x) 则是将 x 元素插入到 s 列表的末尾，等同于 s.append(x)
s.remove(x)
删除 s 列表中第一个 x 元素；如果列表中不存在 x 元素，则抛出 ValueError 异常
s.pop(i)
删除 s 列表中第 i 个元素，并将其返回；如果没有指定 i 参数，s.pop() 将删除最后一个元素并返回
s.clear()
删除 s 列表中的所有元素，相当于 del a[:]
s.index(x[, start[, end]])
返回 x 元素位于 s 列表的索引值（start 和 end 可选，指定开始和结束位置，不过返回的索引值仍然是以序列开始位置计算的）；如果找不到，则返回 ValueError 异常
s.count(x)
返回 x 元素在 s 列表中出现的次数
s.sort(key=None, reverse=False)
对列表中的元素进行原地排序（key 参数指定一个用于比较的函数；reverse 参数用于指定排序结果是否反转）
s.reverse()
原地反转列表中的元素（第一个与最后一个互换，第二个与倒数第二个互换，第三个与倒数第三个互换，...）
s.copy()
返回 s 列表的一个浅拷贝，相当于 s[:]
列表推导式 
基本结构
 
表达式 for 变量 in 迭代对象
 
>>> #给列表中的每个元素乘以2后，输出新的列表
>>> a=[2,3,4,5,6]
>>> for i in range(len(a)):
	a[i]=a[i]*2

	
>>> a
[4, 6, 8, 10, 12]
>>> a=[2,3,4,5,6]
>>> a=[i*2 for i in a]
>>> a
[4, 6, 8, 10, 12]
 
两种方法其实不同：
 
循环通过迭代逐个修改原列表的元素，而列表推导式是直接创造一个新的列表，再把新的列表复制给原变量名。 但是效果相同。
 
>>> #获取右对角线的元素，输出一个新的列表
>>> matrix=[[1,2,3],
	    [4,5,6],
	    [7,8,9]]
>>> n=[matrix[i][2-i] for i in range(3)]
>>> n
[3, 5, 7]
 
创建并初始化二维列表的新方法：
 
>>> #创建并初始化二维列表的新方法：
>>> A=[0]*3
>>> A
[0, 0, 0]
>>> A=[[0]*3 for i in range(len(A))]
>>> A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
 
 表达式 for 变量 in 迭代对象 （if语句）先运行后面的if语句，再进行前面的表达式。
 
>>> a=[i+1 for i in range(10)if i%2==0]
>>> a
[1, 3, 5, 7, 9]
 
列表推导式的嵌套使用：
 
 表达式 for 变量 in 迭代对象 for 变量 in 迭代对象 for 变量 in 迭代对象...
 
外层循环放在前面，内层循环放在后面。
 
​
#把一个二维列表展开成一维列表
>>> matrix=[[1,2,3],
	    [4,5,6],
	    [7,8,9]]
>>> n=[c for r in matrix for c in r]
>>> n
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for r in matrix:
	for c in r:
		n.append(c)

		
>>> n
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 

​
 
元组 
元组是一种序列，不可变 ，可以容纳多种对象（不同的数据类型）。
 
（）或者元组可以不带括号。
 
元组的表示
 
>>> #元组的表示方法

>>> rhy=(1,2,3,"fweaif")

>>> rhy

(1, 2, 3, 'fweaif')

>>> m=1,2,3,"fweaif"

>>> m

(1, 2, 3, 'fweaif')
 
 
访问元组
 
>>> #访问元组（这些操作和列表是一样的）

>>> rhy[2]

3

>>> rhy[-1]

'fweaif'
 
元组的切片操作：
 
其中切片用法和列表的相同。
 
>>> #元组的切片操作

>>> rhy[:]

(1, 2, 3, 'fweaif')

>>> rhy[2:]

(3, 'fweaif')
 
 元组的拼接和重复（和列表相同）
 
>>>#元组的拼接

>>> s=(1,2,4)

>>> t=(2,3,7)

>>> s+t

(1, 2, 4, 2, 3, 7)

>>>#元组的重复

>>> s*3

(1, 2, 4, 1, 2, 4, 1, 2, 4)
 
元组不支持增，删，改，拷贝，只具有查（和列表相同）的功能。
 
​
>>> #增

>>> t.append(5)

Traceback (most recent call last):

 File "", line 1, in 

  t.append(5)

AttributeError: 'tuple' object has no attribute 'append'

>>> 

>>> #删

>>> t.remove(7)

Traceback (most recent call last):

 File "", line 1, in 

  t.remove(7)

AttributeError: 'tuple' object has no attribute 'remove'

>>> #改

>>> s[0]=2

Traceback (most recent call last):

 File "", line 1, in 

  s[0]=2

TypeError: 'tuple' object does not support item assignment

>>> #拷贝

>>> s=t.copy()

Traceback (most recent call last):

 File "", line 1, in 

  s=t.copy()

AttributeError: 'tuple' object has no attribute 

​
 
>>> s=(1,2,4)

>>> t=(2,3,7)
>>> s.count(2)

1

>>> t.index(3)

1
 
 
 
元组支持迭代
 
可以使用循环结构，列表推导式
 
>>> #循环结构

>>>t=(3,4,8)

>>> for i in t:

	print(i)



	

3

4

8

>>> t

>>> t=(2,3,7)

>>> #列表推导式

>>> t=[i+1 for i in t]

>>> t

[3, 4, 8]
 
易错点：生成只有一个元素的元组
 
tuple表示元组
 
补充：type()函数，判断数据类型
 
>>> #生成只有一个元素的元组，加上，

>>> x=(3,)

>>> type(x)



>>> x=(3)

>>> type(x)



>>> y=("f")

>>> type(y)



>>> y=("f",)

>>> type(y)

 
元组的打包和解包
 
生成一个元组（也叫做元组的打包）
 
一次性赋值给多个变量（也叫元组的解包）
 
列表和字符串也有相同的功能。
 
​
>>> #打包

>>> t=[1,2,3,"gsrf"]

>>> #解包

>>> x,y,z,a=t

>>> print(x,y,z,a)

1 2 3 gsrf

>>> a

'gsrf'

​
 
元组本身虽然不可改变，但是元组本身的元素为列表时，元素可以改变，相当于直接修改了列表。
 
>>> t=([2,3,7],[2,5])

>>> t[0][1]=9

>>> t

([2, 9, 7], [2, 5])