目录
一、字符串(string)的相关操作
Python中在双引号或者单引号中的数据,称为字符串。
hi = 'hello world!'
fd = "饺子"
输出字符串print
print("%s"%hi)
print( "今天午饭是%s"%fd)
输入字符串input
userName = input('请输入用户名:')
passWord = input('请输入密码:')
1、下标和切片
下标
例子: str = "abcdef"
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法:[起始:结束:步长] 顾头不顾尾
执行: str[0:3] 不写步长默认为1 结果是 abc
str[4: ] 结果是 ef
str[1:-1] -1就是5 结果是 bcde
2、find
检测一个字符串str是否包含在另一个字符串mystr中如果是返回开始的索引值,否则返回-1。
mystr = "hello world good bye"
str = "bye"
mystr.find(str, 0, len(mystr))
mystr = "hello world good bye" #空格也算
str = "bye"
print(len(mystr))
print(mystr.find(str, 0, len(mystr)))
'''
结果
20
17
进程已结束,退出代码 0
3、index
检测一个字符串str是否包含在另一个字符串mystr中如果是返回开始的索引值,否则报错。
mystr = "hello world good bye"
str = "bye"
mystr.index(str, 0,len(mystr))
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.index(str, 0, 20))
'''
结果
20
17
4、count
返回字符串str在start和end之间在A字符串里面出现的次数
mystr = "hello world good bye"
str = "bye"
mystr.count(str, 0, len(mystr))
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.count(str, 0, len(mystr)))
'''
结果
20
1
'''
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.count("o", 0, len(mystr)))
'''
结果
20
4
'''
5、replace
把字符串mystr中的str1 替换成str2,如果count 指定,
则替换不超过count 次
mystr = "hello world good bye"
str = "bye"
mystr.replace(str1, str2, count(str1))
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.replace(str, "hello world", 1))
'''
结果
20
hello world good hello world
'''
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.replace("o", "g", 2))
'''
20
hellg wgrld good bye
进程已结束,退出代码 0
'''
mystr = "hello world good bye"
str = "bye"
print(len(mystr))
print(mystr.replace("o", "g"))
'''
20
hellg wgrld gggd bye
进程已结束,退出代码 0
'''
6、string 其他方法
如何查看其他方法:
print(dir(str))
如何学习其他的方法:
print(help(str.capitalize))
#print(dir(str))
print(help(str.replace))
'''
Help on method_descriptor:
replace(self, old, new, count=-1, /)
Return a copy with all occurrences of substring old replaced by new.
count
Maximum number of occurrences to replace.
-1 (the default value) means replace all occurrences.
If the optional argument count is given, only the first count occurrences are
replaced.
None
进程已结束,退出代码 0
'''
print(help(str.len))
'''
Help on method_descriptor:
find(...)
S.find(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
None
进程已结束,退出代码 0
'''
二、列表(list)的相关操作
1.列表的定义
定义格式:列表名字 = [第一个值,第二个值, ...... ]
namesList = ['xiaoWang','xiaoZhang','xiaoHua'].
比C语言的数组强大的地方在于列表中的元素可以是不同类型: testList = [1, 'a',3.13]
2.列表的访问
格式:nameList[下标]
例如:print(namesList[0]);
print(namesList[1]);
print(namesList[2])
为了更有效率的输出列表的每个数据,可以使用循环来完成。
a = ['a',12,'asd']
print(a[1])
for i in a:
print(i)
'''
12
a
12
asd
'''
3、列表中的增加
append 通过append可以向列表添加元素(在列表尾部增加一个新元素)
列表名.append(新的值)
extend 通过extend可以将另一个集合中的元素逐一添加到列表中 ()
列表名.extend(新的值)
insert 在指定位置index前插入元素object
列表名.insert(index, object)
a = ['a',12,'asd']
a.append('limeng')
print(a)
#结果 ['a', 12, 'asd', 'limeng']
a = ['a',12,'asd']
b = ['b','c']
a.extend(b)
print(a)
#结果 ['a', 12, 'asd', 'b', 'c']
a = ['a',12,'asd']
a.insert(3,'linxi')
print(a)
#结果 ['a', 12, 'asd', 'linxi']
4、列表中的查找
列表中的查找(in, not in, index, count)
in(存在),如果存在那么结果为true,否则为false
not in(不存在),如果不存在那么结果为true,否则false
index, count 字符串中的用法相同
a = ['a',12,'asd']
a.insert(3,'linxi')
print(12 in a)
print('a' not in a)
print(a.index('asd', 0, 3))
print(a.count("linxi"))
'''
True
False
2
1
进程已结束,退出代码 0
5、删除元素("删"del, pop, remove)
del:根据下标进行删除
pop:删除最后一个元素
remove:根据元素的值进行删除
a = ['a',12,'asd']
a.insert(3,'linxi')
del(a[2])
print(a)
a.pop()
print(a)
a.remove('a')
print(a)
'''
['a', 12, 'linxi']
['a', 12]
[12]
进程已结束,退出代码 0
6、列表中的修改
列表名[下标] = 新的值
a = ['a',12,'asd']
a[0] = 'v'
print(a)
'''
['v', 12, 'asd']
进程已结束,退出代码 0
7、列表的嵌套
列表的嵌套: 一个列表中的元素又是一个列表
schoolNames = [['北京大学','清华大学'], ['南开大学','天津大学','天津师范大学'], ['山东大学','中国海洋大学']]
usrinfo = [['A','B','E'],['F','D'],['C']]
schoolNames = [['北京大学','清华大学'], ['南开大学','天津大学','天津师范大学'], ['山东大学','中国海洋大学']]
print(schoolNames[0][1])
print(schoolNames[1][2])
'''
清华大学
天津师范大学
进程已结束,退出代码 0
三、元组(tuple)的相关操作
1、元组的定义
元组名字 = (值1,值2,......)
aTuple = ('et',77,99.9)
元组的访问访问所有内容
print(aTuple)
('et',77,99.9)
访问元组中一个内容
元组名字[下标]
在定义完元组之后, 不能修改元组内容
a = ('a',12,123.1,'b')
print(a[2])
for i in a:
print(i)
'''
123.1
a
12
123.1
b
进程已结束,退出代码 0
2、查找 (Index 、count )与 len
index 查找值A在元组中的下标位置
元组名字.index(A,start, end)
count 查找值A在元组中出现的次数
元组名字.count(A)
len 求元组的长度
len(元组名字)
a = ('a',12,123.1,'b')
print(a.index('b',2,4))
print(a.count('a'))
print(len(a))
'''
3
1
4
进程已结束,退出代码 0
四、字典(dictionar)的相关操作
1、字典定义 使用{}表示
字典名字 = {键1:值1,键2:值2,......}
字典的特点
字典能够存储多个数据
字典的每个元素由2部分组成,键:值
'name':'zhangsan' 这里 'name'是键 'zhangsan'是值 中间用 冒号: 表示两者之间的关系
2、修改
字典名[键] = 新的值
3、添加
字典名[新的键] = 对应新的值
4、删除
删除一个信息对
del 格式: del 字典名[键]
clear() 格式: 字典名字.clear()
dict = {'name':'乘风归','name2':'向'}
dict['name2'] = '向月明'
print(dict)
dict['落花人独立'] = '微雨燕双飞'
print(dict)
del (dict['name'])
print(dict)
dict.clear()
print(dict)
'''
{'name': '乘风归', 'name2': '向月明'}
{'name': '乘风归', 'name2': '向月明', '落花人独立': '微雨燕双飞'}
{'name2': '向月明', '落花人独立': '微雨燕双飞'}
{}
5、字典的其他方法
len() 字典中键值对长度
格式:len(字典名字)
keys() 字典中所有的键的列表
格式:字典名字.keys()
values() 返回字典中所有的值的列表
格式:字典名字.values()
items 返回一个包含所有(键,值)元祖的列表
格式:字典名字.items()
dict = {'name':'乘风归','name2':'向'}
dict['name2'] = '向月明'
print(dict)
dict['落花人独立'] = '微雨燕双飞'
print(dict)
print(len(dict))
print(dict.keys())
print(dict.values())
print(dict.items())
'''
{'name': '乘风归', 'name2': '向月明'}
{'name': '乘风归', 'name2': '向月明', '落花人独立': '微雨燕双飞'}
3
dict_keys(['name', 'name2', '落花人独立'])
dict_values(['乘风归', '向月明', '微雨燕双飞'])
dict_items([('name', '乘风归'), ('name2', '向月明'), ('落花人独立', '微雨燕双飞')])
进程已结束,退出代码 0
6、字典的遍历
通过for ... in ...:的语法结构,我们可以遍历字符串、列表、元组、字典等数据结构。
实例 --遍历 dict = {'name':'zhangsan','sex':'nan',1:100}
<1> 遍历字典的key(键)
for key in dict.keys():
print(key)
<2> 遍历字典的value(值)
for value in dict.values():
print(value)
<3> 遍历字典的项(元素)
for item in dict.items():
print(item)
dict = {'name':'zhangsan','sex':'nan',1:100}
for key in dict.keys():
print(key)
for value in dict.values():
print(value)
for item in dict.items():
print(item)
'''
name
sex
1
zhangsan
nan
100
('name', 'zhangsan')
('sex', 'nan')
(1, 100)
五、公共方法
1、运算符
a = ['a', 'd']
b = ['b', 'c']
print(a + b)
print(a * 3)
print('a' in a)
print('a' not in a)
'''
['a', 'd', 'b', 'c']
['a', 'd', 'a', 'd', 'a', 'd']
True
False
2、python内置函数
cmp(x,y) :如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
python3中删除了cmp函数
a = ['a', 'd','2','3']
print(max(a))
print(min(a))
'''
d
2
进程已结束,退出代码 0
d5作业
1、写代码,有如下变量,请按照要求实现每个功能
name = " aleX"
a. 移除 name 变量对应的值两边的空格,并输入移除有的内容
print(name.strip())#用于移除字符串头尾指定的字符(默认为空格或换行符)或字符序列
b.判断 name 变量对应的值是否以 "al" 开头,并输出结果
startswith() 方法用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False。如果参数 beg 和 end 指定值,则在指定范围内检查。
str.startswith(str, beg=0,end=len(string));
- str -- 检测的字符串。
- strbeg -- 可选参数用于设置字符串检测的起始位置。
- strend -- 可选参数用于设置字符串检测的结束位置。
c.判断 name 变量对应的值是否以 "X" 结尾,并输出结果
endswith() 方法用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True,否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
str.endswith(suffix[, start[, end]])
- suffix -- 该参数可以是一个字符串或者是一个元素。
- start -- 字符串中的开始位置。
- end -- 字符中结束位置。
d.将 name 变量对应的值中的 “ l” 替换为 “ p”,并输出结果
name = name.replace('l','p')
print(name)
e.将 name 变量对应的值根据 “ l” 分割,并输出结果。
split() 通过指定分隔符对字符串进行切片,如果参数 num 有指定值,则分隔 num+1 个子字符串
str.split(str="", num=string.count(str)).
- str -- 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等。
- num -- 分割次数。默认为 -1, 即分隔所有。
f.请问,上一题 e分割之后得到值是什么类型?
列表
g.将 name 变量对应的值变大写,并输出结果
upper() 方法将字符串中的小写字母转为大写字母。
str.upper()
返回小写字母转为大写字母的字符串。
h.将 name 变量对应的值变小写,并输出结果
print(name.lower())#将字符串中所有大写字符转换为小写后生成的字符串。
i.请输出 name 变量对应的值的第 2 个字符?
print(name[1])
j. 请输出 name 变量对应的值的前 3 个字符?
print(name[0:3])
k. 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
l.请输出 name 变量对应的值中 “ e” 所在索引位置?
print(name.find('e'))
name = " aleX "
print(name.strip())#用于移除字符串头尾指定的字符(默认为空格或换行符)或字符序列
print(name.startswith('al'))#用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False。如果参数 beg 和 end 指定值,则在指定范围内检查
print(name.endswith('X'))#用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True,否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
print(name.replace('l','p'))
print(name.split('l'))# split() 通过指定分隔符对字符串进行切片,如果参数 num 有指定值,则分隔 num+1 个子字符串
print(type(name.split('l')))
print(name.upper())#upper() 方法将字符串中的小写字母转为大写字母。
print(name.lower())#将字符串中所有大写字符转换为小写后生成的字符串。
print(name[1])
print(name[0:3])
print(name[-2:])
print(name.find('e'))
'''
aleX
False
False
apeX
[' a', 'eX ']
<class 'list'>
ALEX
alex
a
al
X
3
进程已结束,退出代码 0
2、写代码,有如下列表,按照要求实现每一个功能
li = ['alex','eric','rain']
a.计算列表长度并输出
b.列表中追加元素 “seven”,并输出添加后的列表
c.请在列表的第1个位置插入元素 “Tony”,并输出添加后的列表
d.请修改列表第2个位置的元素为 “Kelly”,并输出修改后的列表
e.请删除列表中的元素 “eric”,并输出修改后的列表
li = ['alex','eric','rain']
print(len(li))
li.append('seven')#只是修改操作,无返回值
print(li)
li.insert(0,'Tony')
print(li)
li[1] = 'Kelly'
print(li)
del(li[2])
print(li)
'''
3
['alex', 'eric', 'rain', 'seven']
['Tony', 'alex', 'eric', 'rain', 'seven']
['Tony', 'Kelly', 'eric', 'rain', 'seven']
['Tony', 'Kelly', 'rain', 'seven']
进程已结束,退出代码 0
3、写代码,有如下元组,按照要求实现每一个功能
tu=('alex','eric','rain')
a.计算元组长度并输出
b.获取元组的第2个元素,并输出
c.获取元组的第 1-2个元素,并输出
d.请使用 for 输出元组的元素
e.请使用 for、len、range 输出元组的索引
tu=('alex','eric','rain')
print(len(tu))
print(tu[1])
print(tu[0:2])
print('')
for i in tu:
print(i)
print('')
for i in range(len(tu)):#输出元组的索引
print(i)
'''
3
eric
('alex', 'eric')
alex
eric
rain
0
1
2
进程已结束,退出代码 0
4、字典
dic ={'k1':"v1","k2":"v2","k3":[11,22,33]}
a.请循环输出所有的 key
b.请循环输出所有的value
c.请循环输出所有的 key 和 value
d.请在字典中添加一个键值对,"k4":"v4",输出添加后的字典
e.请在修改字典中 “k1” 对应的值为 “alex”,输出修改后的字典
f.请在 k3 对应的值中追加一个元素44,输出修改后的字典
g.请在 k3 对应的值的第1个位置插入个元素18,输出修改后的字典
dic ={'k1':"v1","k2":"v2","k3":[11,22,33]}
for key in dic.keys():
print(key)
print('')
for value in dic.values():
print(value)
print('')
for item in dic.items():
print(item)
print('')
dic['k4'] = 'v4'
print(dic)
print('')
dic['k1'] = 'alex'
print(dic)
print('')
dic['k3'].append(44)#请在k3对应的值中追加一个元素44,输出修改后的字典
print(dic)
print('')
dic['k3'].insert(0,18)
print(dic)
'''
k1
k2
k3
v1
v2
[11, 22, 33]
('k1', 'v1')
('k2', 'v2')
('k3', [11, 22, 33])
{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
{'k1': 'alex', 'k2': 'v2', 'k3': [18, 11, 22, 33, 44], 'k4': 'v4'}
进程已结束,退出代码 0