python基础学习第四天

1. 列表、元组和 字符串

一、列表
简单数据类型：
int 整型
float 浮点型
bool 布尔型

容器数据类型：
list 列表
tuple 元组
dict 字典
set 集合
str 字符串

1、列表定义：
[元素1，元素2，，，，元素n]

2、列表的创建

a=[1,2,3,4,5,6,7]
print(type(a))
b=['t','r','a','c','e','y']
print(b,type(b))

结果为：

<class 'list'>
['t', 'r', 'a', 'c', 'e', 'y'] <class 'list'>

利用range（）创建列表：

a=list(range(1,10,2))
print(a)
b=list(range(10,1,-2))
print(b)

range输出从第一个开始到第二个值的前一个结束，步长为第三个值。

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

利用推导式创建列表：

x=[0]*10
print(x)
x=[i for i in range(10)]
print(x)
x=[i**2 for i in range(1,10,2)]
print(x)
x=[i for i in range(100) if (i%2==0) and (i%3==0)]
print(x)

if语句记得要加上括号，结果为：

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 9, 25, 49, 81]
[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

创建一个4X3的二维数组：

x = [[1,2,3],[4,5,6],[7,8,9],[10,10,10] ]
print(x)
for i in x:
    print(i,type(i))

多维数组里面也包含一维数组；

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 10, 10]]
[1, 2, 3] <class 'list'>
[4, 5, 6] <class 'list'>
[7, 8, 9] <class 'list'>
[10, 10, 10] <class 'list'>

数组赋值：

x=[[1 for col in range(4)] for row in range(2)]
print(x)
x[0][0]=0
print(x)
x=[[0]*3 for row in range(5)]
print(x)
x[2][1]=2
print(x)

可以通过X[][]对数组赋值。

[[1, 1, 1, 1], [1, 1, 1, 1]]
[[0, 1, 1, 1], [1, 1, 1, 1]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 2, 0], [0, 0, 0], [0, 0, 0]]

注意：

由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

x=[[2]*5 for i in range(3)]
print(x,type(x))
x[0][0]=1
print(x,type(x))

a=[3]*4
x=[a]*4
print(x,type(x))
x[2][2]=1
print(x,type(x))

第二种情况下，改变数组的值，可以改变一整列。

[[2, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] <class 'list'>
[[1, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] <class 'list'>
[[3, 3, 3, 3], [3, 3, 3, 3], [3, 3, 3, 3], [3, 3, 3, 3]] <class 'list'>
[[3, 3, 1, 3], [3, 3, 1, 3], [3, 3, 1, 3], [3, 3, 1, 3]] <class 'list'>

创建一个空列表：

empty=[]
print(empty,type(empty))

[] <class 'list'>

3、向列表中添加元素：

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

a=[1,2,3,4,5]
a.append(2)
a.append('dhueh')
print(a)
a.append(2,'d')
print(len(a))

append 只接受一个参数，传入的参数可以是任何格式，被追加的元素在list中保持原结构类型。

此元素如果是一个list， 那么这个list将作为一个整体进行追加，注意append（）和extend（）的区别。

a=[1,2,3,4,5]
a.append(2)
a.append('dhueh')
print(a)
a.append([10,11])
a.extend([2,3])
print(a,len(a))

[1, 2, 3, 4, 5, 2, 'dhueh']
[1, 2, 3, 4, 5, 2, 'dhueh', [10, 11], 2, 3] 10

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

list.insert(index, obj) 在编号 index 位置插入 obj

a.insert(3,'kafgh')
print(a,len(a))

[1, 2, 3, 4, 5, 2, 'dhueh', [10, 11], 2, 3] 10
[1, 2, 3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2, 3] 11

4、删除列表中的元素：

list.remove(obj) 移除列表中某个值的第一个匹配项

a.remove(1,2,3)
print(a)

注意：这里只能传入一个参数。

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

a.remove(1)
print(a)
a.pop()
print(a)
a.pop(0)
print(a)

[1, 2, 3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2, 3] 11
[2, 3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2, 3]
[2, 3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2]
[3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2]

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

del var1[, var2 ……] 删除单个或多个对象。

del a[0:2]
print(a)

删除前两个元素：

[3, 'kafgh', 4, 5, 2, 'dhueh', [10, 11], 2]
[4, 5, 2, 'dhueh', [10, 11], 2]

5、获取列表中的元素

print(a[3],type(a[3]),a[1],type(a[1]),a[4],type(a[4]))


5 <class 'int'> kafgh <class 'str'> [10, 11] <class 'list'>

切片的通用写法是 start : stop : step

情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片。
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。

print(a[3:],a[:3],a[:-3],a[-3:])


[3, 'kafgh', 4, 5, [10, 11], 2]
[5, [10, 11], 2] [3, 'kafgh', 4] [3, 'kafgh', 4] [5, [10, 11], 2]

情况 3 - “start : stop”
以 step 为 1 (默认) 从编号 start 往编号 stop 切片。

情况 4 - “start : stop : step”
以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。

print(a[1:4:2],a[1:3],a[-3:-1],a[4:1:-1],a[::2],a[:-3:1])


[3, 'kafgh', 4, 5, [10, 11], 2]
[5, [10, 11], 2] [3, 'kafgh', 4] [3, 'kafgh', 4] [5, [10, 11], 2]
['kafgh', 5] ['kafgh', 4] [5, [10, 11]] [[10, 11], 5, 4] [3, 4, [10, 11]] [3, 'kafgh', 4]

情况 5 - " : "
复制列表中的所有元素（浅拷贝）

a=[1,4,2,3,6,5,7,10,3,4]
b=a
c=a[:]
print(b,c)
a.sort()
print(a,b,c)

浅拷贝与深拷贝：

[1, 4, 2, 3, 6, 5, 7, 10, 3, 4] [1, 4, 2, 3, 6, 5, 7, 10, 3, 4]
[1, 2, 3, 3, 4, 4, 5, 6, 7, 10] [1, 2, 3, 3, 4, 4, 5, 6, 7, 10] [1, 4, 2, 3, 6, 5, 7, 10, 3, 4]

改变数组中的元素：

a=[[1,2,3],[4,5,6],[7,8,9]]
b=a
c=a[:]
print(b,c)
a[0][0]=21
print(b,c)

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

这里的赋值都是一样的，但是排序只对深拷贝有影响。

6、列表的常用操作符

等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

print(a==b)
print(b==c)
e=a+b
print(e)
print(a[1])
print(a[1]+b[2])
print(a[1]*3)
a[1]*=3
print(a[1])
print(1 in a[1])
print(1 not in a[2])

True
True
[[21, 2, 3], [4, 5, 6], [7, 8, 9], [21, 2, 3], [4, 5, 6], [7, 8, 9]]
[4, 5, 6]
[4, 5, 6, 7, 8, 9]
[4, 5, 6, 4, 5, 6, 4, 5, 6]
[4, 5, 6, 4, 5, 6, 4, 5, 6]
False
True

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

7、列表的其他用法：

a=[1,2,3]*3
print(a)
num=a.count(1)
print(num)


[1, 2, 3, 1, 2, 3, 1, 2, 3]
3

list.count(obj) 统计某个元素在列表中出现的次数

list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

a=[1,2,3]*3
print(a)
num=a.count(1)
print(num)
print(a.index(2))
print(a.index(2,5,8))

[1, 2, 3, 1, 2, 3, 1, 2, 3]
3
1
7

list.reverse() 反向列表中元素

a.reverse()
print(a)

[1, 2, 3, 1, 2, 3, 1, 2, 3]
[3, 2, 1, 3, 2, 1, 3, 2, 1]

list.sort(key=None, reverse=False) 对原列表进行排序。

key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。

a=[1,4,2,3,5]
a.sort()
print(a)
a.sort(reverse=True)#降序排列
print(a)

[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

def TakeSecond(elem):
    return elem[1]
x=[[1,3],[2,4],[3,2]]
x.sort(key=TakeSecond,reverse=True)
print(x)
x.sort(key=lambda x:x[0])
print(x)

[[2, 4], [1, 3], [3, 2]]
[[1, 3], [2, 4], [3, 2]]

二、元组

「元组」定义语法为：(元素1, 元素2, …, 元素n)

小括号把所有元素绑在一起
逗号将每个元素一一分开

1、创建和访问一个元组
python的元组与列表类似，不同之处在于tuple被创建之后不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引和切片

a=(1,2,3,4,5)
print(a,type(a))
b=('1','2','3','4')
print(b,type(b))
c=a+b
print(c,type(c))
d=(2)
print(d,type(d))

(1, 2, 3, 4, 5) <class 'tuple'>
('1', '2', '3', '4') <class 'tuple'>
(1, 2, 3, 4, 5, '1', '2', '3', '4') <class 'tuple'>
2 <class 'int'>

元组的访问与列表一样：

a=(1,2,3,4,5,6,7,8)
print(a)
print(a[5:])
print(a[:-3])
b=a[:]
print(b)

输出结果为：

(1, 2, 3, 4, 5, 6, 7, 8)
(6, 7, 8)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5, 6, 7, 8)

创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

a=(1)
print(a,type(a))
a=1,2,3,4,5
print(a,type(a))
a=1
print(type(a))
a=[]
print(type(a))
a=()
print(type(a))
a=(1,)
print(a,type(a))

输出结果为：

1 <class 'int'>
(1, 2, 3, 4, 5) <class 'tuple'>
<class 'int'>
<class 'list'>
<class 'tuple'>
(1,) <class 'tuple'>

如果不加（），会当做整型输出：

print(8*(8))
print(8*(8,))


64
(8, 8, 8, 8, 8, 8, 8, 8)

创建二维元组：

a=(1,2,3,'hudwid'),(2,3,4,6,6,8)
print(a)
print(a[0])
print(a[0][1:3])

((1, 2, 3, 'hudwid'), (2, 3, 4, 6, 6, 8))
(1, 2, 3, 'hudwid')
(2, 3)

2、更新和删除一个元组：

m=('a','b','c','d')
m=m[:2]+('v',)+m[2:]
print(m)

('a', 'b', 'v', 'c', 'd')

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

a=(1,2,3,[23,45])
print(a)
a[3][0]=8
print(a)


(1, 2, 3, [23, 45])
(1, 2, 3, [8, 45])

3、元组的相关操作符
等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。

元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

a=(1,2,3)
b=(4,5,6)
c=(7,8,9)
d=(1,2,3)
print(a==d)
print(a==b)
m=a+b
print(m)
n=a*3
print(n)
a*=3
print(a)
print(3 in a)
print(3 not in a)

输出结果为：

True
False
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
False

4、内置方法
元组大小和内容都不可更改，因此只有 count 和 index 两种方法。

t=(1,2,3,'hdqyg')
print(t.count(2))
print(t.index(3))

1
2

5、解压元组：
解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t=(1,2,3,('hdqyg',1,3))
print(t)
print(t.count(1))
print(t.index(3))
(a,b,c,(d,e,f))=t
print(a,b,c,d,e,f)


(1, 2, 3, ('hdqyg', 1, 3))
1
2
1 2 3 hdqyg 1 3

三、字符串

1、字符串的定义
Python 中字符串被定义为引号之间的字符集合。
Python 支持使用成对的 单引号 或 双引号。

a='I am  Tracey'
print(a,type(a))
print(1+2)
b='1'+'2'
print(b,type(b))
print('3')

输出结果：

I am  Tracey <class 'str'>
3
12 <class 'str'>
3

python常用制表符：
义字符 描述
\ 反斜杠符号
’ 单引号
" 双引号
\n 换行
\t 横向制表符(TAB)
\r 回车
当字符串中出现单引号和双引号的时候，可以使用转义符号\对字符串进行转义。

原始字符串只需要在字符串前边加一个英文字母 r 即可

a='I\'m a beautiful girl'
print(a)
b='a:\\j'
print(b)
print('c:\eh \\bjwdbdjk\jdh\eud')
print(r'c:\eh \\bjwdbdjk\jdh\eud')


I'm a beautiful girl
a:\j
c:\eh \bjwdbdjk\jdh\eud
c:\eh \\bjwdbdjk\jdh\eud

本文地址：https://blog.csdn.net/qq_41048228/article/details/107620294