Python 基础二

Python 基础二

  • 2020-07-07
  • 次

Python 基础二

知识点

1、字符串（str)

1.1 字符串的定义

用单引号，双引号，三个引号包围的字符

1
2
3
4
str = 'hello' # 定义字符串变量
str = "hello"
str = """hello
hello""" # 定义多行字符串变量
1
2
3
4
5
6
7
8
9
10
11
# 字符串
my_str = 'hello'
#  h  e  l  l  o
#  0  1  2  3  4 索引
# -5 -4 -3 -2 -1
# 根据索引取值（不能越界）
# print(my_str[4])

# 获取最后一个元素
# print(my_str[-1])
# print(my_str[len(my_str)-1])

1.2 下标和切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 切片
my_str = 'hello'
# 数据[起始位置:结束位置:步长] 步长默认是 1,结束位置不包含
# result = my_str[1:4:1]
# result = my_str[:4]
# print(my_str[1:5])
# print(my_str[1:])

# 负数索引
# print(my_str[-2: :-1])

# 倒着获取数据
# result = my_str[-1:-6:-1]
# result = my_str[::-1]
# print(result)
# type()
print(type(my_str))

注：可用 dir(str) 查看 str. 可进行的操作

1
2
3
4
5
6
7
8
9
10
11
12
# 遍历 ，for
my_str = 'hello'
# for value in range(0,len(my_str)):
#     print(my_str[value])

# 可迭代对象（可遍历对象，list tuple)

# for value in my_str:
#     print(value)

for index,value in enumerate(my_str):
    print(index,value)

1.3 字符串的常见操作

如果有字符串 my_str =”hello world kkb”, 一下常见操作

1、find

检测 str 是否包含在 mystr 中，如果是返回开始索引值，否则返回-1

1
my_str.find (str,start = 0,end = len(mystr))

例如：

1
2
3
4
5
my_str = 'hello world kkb'
my_str.find("kkb")
运行结果为：12
my_str.find('kkb',0,10)
运行结果为-1

2、index

和 find() 方法一样，不同的是如果 str 不在 my_str 那么会报错

1
my_str.index(str,start = 0,end = len(my_str))

例如：

1
2
3
my_str = "hello world kkb"
my_str.index("ab")
会报错

3、count

返回 str 在 start 和 end 之间出现的次数

1
mystr.count(str,start=0,end=len(mystr))

例如：

1
2
3
mystr = "hello world kkb and kkb"
mystr.count('kkb')
运行结果：2

4、replace

把 mystr 中的 str1 替换成为 str2 ,如果 count 指定则不超过 count 次

1
mystr.replace(str1,str2,mystr.count(str1))

5、split

以 str 为分隔符切片 mystr ,如果 maxsplit 有指定值，则仅分割 maxsplit 个字符

1
mystr.split(str='',2)

6、capitalize

把字符串的第一个字符大写

1
mystr.capitalize()

7、title

1
2
3
4
a = 'hello world'
a.title()
运行结果
”Hello World“

8、stratswith

检查字符串是否以 hello 开头，是则返回 True,否则返回 False

1
mystr.startswith(hello)

9、endswith

检查字符串是否以 obj 结束，如果是返回 Ture ，否则返回 False

1
mystr.endswith(obj)

10、lower

转换 mystr 中的大写字符为小写

1
mystr.lower()

11、upper

转换 mystr 中的小写为大写

1
mystr.upper()

12、ljust

返回一个元字符串左对齐，并且空格填充至长度 width 的新字符串

1
mystr.ljust(width)

13、rjust

返回一个元字符串右对齐，并且空格填充至长度 width 的新字符串

1
mystr.rjust(width)

14、center

返回一个字符串居中，并用空格填充至长度 width

1
mystr.center(width)

15、lstrip

删除 mystr 左边的空白字符

1
mystr.lstrip()

16、rstrip

删除 mystr 右边的空白字符串

1
mystr.rstrip()

17、strip

删除 mystr 字符串两端的空白符

1
2
3
4
a = "\n \t kkb \t\n"
a.strip()
运行结果：
’kkb‘

18、rfind

类似于 find() 函数，不过是从右边开始查找

1
mystr.rfind(str,strat=0,end=len(mystr))

19、rindex

类似于 index() 不过从右边开始查找

1
mystr.rindex(str,start=0,end=len(mystr))

20、partition

把 mystr 以 str 分割成三部分，str 前，str，str 后

1
mystr.partition(str)

21、rpartition

类似于 partition 只不过从右边开始

1
mystr.rpartition(str)

22、splitlines（）

按照分格符，返回一个包含各行作为元素的列表

1
mystr.splitlines()

23、join

mystr 中的每个元素后面插入 str ，构造有个新字符串

1
mystr.jion(str)

2、列表（list）

2.1 列表简介

python 中内置一种数据类型列表：list。 list 是一种有序的集合，可以随时添加和删除其中的元素，写在方括号之间、用逗号分隔。列表内的项目不必是相同的类型。

例如：

1
list1 = ['spam','eggs',100,1234]

2.2、列表的常见操作

1、列表的长度

1
2
3
# 用len()函数可以获得list元素的个数；
nameslist = ['xiaowang','xiaozhang','xiaohua']
len(nameslist)

2、列表的访问

用索引来访问 list 中的每一个元素，记得索引从 0 开始：

1
2
3
4
5
6
7
8
9
10
nameslist = ['xiaowang','xiaozhang','xiaohua']
	print(nameslist[0])
  print(nameslist[1])
  print(nameslist[2])
  print(nameslist[3])
  结果：
  xiaowang
  xiaozhang
  xiaohua
  报错：list index out of range
  • 注意：当索引超出范围，python 会报错 indexError，所以确保索引不要越界，最后一个元素的索引是 len(nameslist)-1, 或者直接用-1。
1
2
3
4
nameslist = ['xiaowang','xiaozhang','xiaohua']
print[nemeslist[-1]]
结果：
xiaohua

3、列表的切片

切片：根据下标的范围获取一部分数据，比如：列表，字符串

1
2
3
切片的使用格式
数据[起始下标：结束下标：步长]
提示：起始下标默认为 0，结束下标是不包含的，步长为 1
1
2
3
4
5
6
7
8
9
# 使用切片方法获得一部分数据
result = my_str[1:4:1]
print(result)

# 前三个
result = my_str[0:3]
print(result)
result = my_str[:3]
print(result)

4、添加元素（append,extend,insert）

通过 append 可以向列表添加元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 定义变量A，默认有三个元素
A = ['xiaowang','xiaozhang','xiaohua']
print("-----添加之前，列表A的数据-----")
for tempName in A:
		print(tempName)
# 提示、并添加元素
temp = input('请输入要添加的学生的名字')
A.append(temp)

print('-----添加滞后，列表A的数据-----')
for tempName in A:
  	print(tempName)
    
    
结果：
-----添加之前，列表A的数据-----
xiaowang
xiaozhang
xiaohua
请输入要添加的学生的名字xiaoyu
-----添加滞后，列表A的数据-----
xiaowang
xiaozhang
xiaohua
xiaoyu

通过 extend 可以将一个集合中的元素逐一添加到列表中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = [1,2]
b = [3,4]
a.append(b)
print(a)

a.extend(b)
print(a)

# insert(index,objiet) 在指定位置 index 输入元素object
a = [0,1,2]
a.insert(1,3)
print(a)

结果：
[1, 2, [3, 4]]
[1, 2, [3, 4], 3, 4]
[0, 3, 1, 2]

5、修改元素

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 定义变量 A ,有 3 个元素
A = ['xiaowang','xiaozhang','xiaohua']
print('------修改之前，列表A的数据------')
for tempName in A: 
    print(tempName)
# 修改元素
A[1] = 'xiaolu'
print('-----修改之后，列表A的数据-----')
for tempName in A: 
    print(tempName)

结果：
------修改之前，列表A的数据------
xiaowang
xiaozhang
xiaohua
-----修改之后，列表A的数据-----
xiaowang
xiaolu
xiaohua

6、查找元素

所谓查找元素，就是看看指定元素是否存在

python 中查找的常用方法为：

  • in 存在，如果存在那么返回结果为 True 否则为 False
  • not in 不存在，如果不存在那么结果为 Ture 否则为 False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 待查找的对象
nameList = ['xiaowang','xiaozhang','xiaohua']

# 获取用户要查找的名字
findName = input('请输入要查找的名字：')

# 查找是否存在
if findName in nameList:
    print('在字典中找到了相同的名字')
else:
    print('没找到')

结果：
请输入要查找的名字：xiaoming
没找到

index 和 count 与字符串中的用法相同

1
2
3
4
5
a = ['a','b','c','a','b']
# a.index('a',1,3) 这一条会报错
a.index('a',1,4)
a.count('b')
a.count('d')

7、删除元素

列表元素常用删除方法：

  • del: 根据下标进行删除
  • pop：删除最后一个元素
  • remove: 根据元素的值进行删除

（1）del

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
list1 = ['a','b','c','d','e','f']
print('-----删除之前-----')
for tempName in list1:
    print(tempName)
del list1[2]
print('-----删除之后-----')
for tempName in list1:
    print(tempName)
   
结果：
-----删除之前-----
a
b
c
d
e
f
-----删除之后-----
a
b
d
e
f

（2）pop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
list2 = ['a','b','c','d','e','f']
print('-----删除之前-----')
for tempName in list2:
    print(tempName)
list2.pop()
print('-----删除之后-----')
for tempName in list2:
    print(tempName) 

结果：
-----删除之前-----
a
b
c
d
e
f
-----删除之后-----
a
b
c
d
e

（3）remove

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
list3 = ['a','b','c','d','e','f']
print('-----删除之前-----')
for tempName in list3:
    print(tempName)
list2.remove('e')
print('-----删除之后-----')
for tempName in list3:
    print(tempName)
    
结果：
-----删除之前-----
a
b
c
d
e
f
-----删除之后-----
a
b
c
d
f

（4）排序

sort 方法是将 list 按特定殊勋重新排列，默认为由小到大，参数 reverse=true 可改为倒序，由大到小

reverse 方法是将 list 逆置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = [1,4,2,3]
print(a)
a.reverse()
print(a)
a.sort()
print(a)
a.sort(reverse=True)
print(a)

结果：
[1, 4, 2, 3]
[3, 2, 4, 1]
[1, 2, 3, 4]
[4, 3, 2, 1]

2.3、列表的遍历

1、使用 for 循环

为了有效的输出列表的每个数据，可以使用循环来完成

1
2
3
4
5
6
7
8
namesList = ['xiaowang','xiaozhang','xiaohua']
for name in namesList:
    print(name)
 
结果：
xiaowang
xiaozhang
xiaohua

2、使用 while 循环

为了更有效的输出列表的每个数据，可以使用循环来完成

1
2
3
4
5
6
7
8
9
10
11
namesList = ['xiaowang','xiaozhang','xiaohua']
length = len(namesList)
i = 0 
while i<length:
    print(namesList[i])
    i += 1 
    
结果：
xiaowang
xiaozhang
xiaohua

3、元组（tuple）

另外一种有序列表叫元组：tuple, tuple 和 list 类似，但是 tuple 一旦初始化不能更改，比如同样累出同学的名字：

1
classmates = ('Michael','Bob',Tracy)

现在，classmates 这个 tuple不能变了，它没有 append(),insert() 这样的方法。其他获取元素的方法和 list 一样，可以正常使用 classmate[0],xlassmate[1],但是不能赋值成为另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。不过可能，能用tuple代替list就尽量用tuple。

1
2
3
4
5
# 定义一个 tuple 可以写成（）
t = ()
print(t)

()

但是，如果要定义一个只有1个元素的tuple, 如果这么定义：

1
2
3
4
t = (1)
print(t)

1

定义的不是tuple，而是1这个数！因为这个（）既可以表示tuple,也可以此表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况看小括号计算，计算结果是 1

所以只有一个元素的tuple定义时必须加个逗号 ，来消除歧义

1
2
3
4
t = (1,)
print(t)

(1,)

python在显示只有一个元素的tuple时，也会加个逗号，以免产生误解。

1
2
3
4
5
6
7
t = ('a','b',['A','B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)

结果：
('a','b',['X','Y'])

4、字典（dict）

4.1、字典简介

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值（key=>value)对用冒号（：）分割，每个对之间用逗号（，）分割，整个字典包括在花括号{}中

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

1
2
names = ['Micheal','Bob','Tracy']
score =[95,97,98]

给定一个名字，要查找对应的成绩，就先要在names中找到对顶的位置，再从scores取出对应的成绩，list越长，耗时越长。

如果用 dict 实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表多大，查找速度都不会变慢。用Python写一个dict如下：

1
2
3
4
d = {'Micheal':95,'Bob':75,'Tracy':85}
d['Micheal']

95

由于一个 key 只能对应一个value，所以，多次对一个key放入value，后面的值会吧前面的值冲掉：

1
2
3
4
5
6
7
8
9
d['Jack'] = 90
d['Jack']

90

d['Jack'] = 88
d['Jack']

88

如果key不存在，dic就会报错：

1
2
d['Thomas']
报错

4.2 字典的常规操作

（1）修改元素

每个字典中的数据是可以修改的，只要通过key找到，即可修改

1
2
3
4
info = {'name':'kkb','sex':'f','address':'中国北京'}
new_id = input('请输入新的学号：')
info['id'] = int(new_id)
print('修改滞后的id为：%d' % info['id'])

（2） 添加元素

1
2
3
4
5
6
7
8
9
10
11
info = {'name':'kkb','sex':'f','address':'中国北京'}
print('id为：%d' % info['id'])

结果：
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-1-537dc1e23114> in <module>
      1 info = {'name':'kkb','sex':'f','address':'中国北京'}
----> 2 print('id为：%d' % info['id'])

KeyError: 'id'

如果在使用 变量名[‘键’] = 数据 时，这个‘键’在字典中，不存在，那么就会新增这个元素。

添加新的元素

1
2
3
4
5
6
7
8
info = {'name':'kkb','sex':'f','address':'中国北京'}
# print('id为：%d' % info['id'])
newId = input('请输入新的学号：')
info['id'] = int(newId)
print('添加滞后的id为:%d' % info['id'])

请输入新的学号：888
添加滞后的id为:888

（3）删除元素

对字典进行删除操作，有以下几种

  • del
  • clear()

del 删除指定的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
info = {'name':'kkb','sex':'f','address':'中国北京'}
print('删除前，%s' % info['name'])
del info['name']
del info['name']
print('删除后，%s' % info['name'])

删除前，kkb
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-11-fb8f36e7ab49> in <module>
      2 print('删除前，%s' % info['name'])
      3 del info['name']
----> 4 del info['name']
      5 print('删除后，%s' % info['name'])

KeyError: 'name'

del 删除整个字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
info = {'name':'kkb','sex':'f','address':'中国北京'}
print('删除前，%s' % info)
del info
print('删除后，%s' % info)

删除前，{'name': 'kkb', 'sex': 'f', 'address': '中国北京'}
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-d5ad1a4a8131> in <module>
      2 print('删除前，%s' % info)
      3 del info
----> 4 print('删除后，%s' % info)

NameError: name 'info' is not defined

clear 清楚整个字典

1
2
3
4
5
6
7
info = {'name':'kkb','sex':'f','address':'中国北京'}
print('删除前，%s' % info)
info.clear()
print('清除后，%s' % info)

删除前，{'name': 'kkb', 'sex': 'f', 'address': '中国北京'}
清除后，{}

（4）len()

测量字典中，键值对的个数

1
2
3
4
d1 = {'name':'kkb','sex':'f','address':'中国北京'}
print(len(d1))

3

（5）keys

返回一个包含字典所有key的列表

1
2
3
4
5
6
d1 = {'name':'kkb','sex':'f','address':'中国北京'}
print(d1.keys())
print(list(d1.keys()))

dict_keys(['name', 'sex', 'address'])
['name', 'sex', 'address']

（6）values

返回一个包含字典所有value的列表

1
2
3
4
5
6
d1 = {'name':'kkb','sex':'f','address':'中国北京'}
print(d1.values())
print(list(d1.values()))

dict_values(['kkb', 'f', '中国北京'])
['kkb', 'f', '中国北京']

（7）items

返回一个包含所有（键，值）元组的列表

1
2
3
4
5
6
d1 = {'name':'kkb','sex':'f','address':'中国北京'}
print(d1.items())
print(list(d1.items()))

dict_items([('name', 'kkb'), ('sex', 'f'), ('address', '中国北京')])
[('name', 'kkb'), ('sex', 'f'), ('address', '中国北京')]

（8）has_key (python3 已取消)

dict.has_key(key) 如果key在字典中，返回Ture, 否则返回 False。

5、集合（set）

集合（set）是一个无序不重复元素序列

可以使用大括号{} 或者set() 函数创建集合，注意创建一个空集合必须使用 set(), 因为{} 是用来创建空字典的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# my_set = {1,4,'abc','hello'}
# 不支持下标赋值和取值
# my_set[0] = 3
# value = my_set[0]
# print(value)

# 通过遍历获取数据
my_set = {1,5,7}
for value in my_set:
    print(value)
    
for index,value in enumerate(my_set):
    print(index,value)
    
# 定义空的集合时不能直接使用{}

my_set = set()
my_set.add(1)
my_set.add(1)
print(my_set,type(my_set))

# 集合可以对容器类型数据去重
my_list = [1,1,3,5,3]
# 把列表转换为集合
my_set = set(my_list)
print(my_set)

# 列表，元组，集合 三者可以相互转换
my_tuple = (5,3)
print(my_tuple,type(my_tuple))


1
5
7
0 1
1 5
2 7
{1} <class 'set'>
{1, 3, 5}
(5, 3) <class 'tuple'>
感谢您的阅读，本文由 LEE 版权所有。如若转载，请注明出处：LEE（https://ChubbyLEE-Math.github.io/2020/07/07/python%20%E5%9F%BA%E7%A1%80%E4%BA%8C/）
Python 基础一
Python 基础三