江西农业大学Python期末复习2字符串输入输出组合python数据类型

声明，本文参考了菜鸟教程中的Python章节

1.Python字符串输入输出

1.1字符串表示

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

三引号可以包围多行字符串。三引号可以保留所有字符串的格式信息，如果字符串跨越多行，行与行之前的回车符也可以保存下来，引号、制表符、或者其他任何信息都可以保存下来。利用这种方式，可以将整个段落作为单个字符保存下来处理。

#三引号
c3='''dog
tiger
monkey
bird
'''
print(c3)
#运行结果
dog
tiger
monkey
bird

1.2转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：

转义字符	描述
\ (在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
\f	换页
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
\other	其它的字符以普通格式输出

print("he said :\"Let’s go to play!\"")
#运行结果
he said :"Let’s go to play!"

1.3格式化字符串

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

• Python支持的两种字符串格式化方法:

1. 使用格式化操作符%
2. 采用专门的str.format()方法

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
#运行结果
我叫 小明 今年 10 岁!

• format()方法

  #位置参数
  print("{} is {} years old.".format("Lucy",20))
  print("{0} is {1} years old.".format("Lucy",20))
  print("Hello {0}!{0} is {1} years old.".format("Lucy",20))
  #运行结果
  Lucy is 20 years old.
  Lucy is 20 years old.
  Hello Lucy!Lucy is 20 years old.
  

  位置参数匹配，如果占位符{}为空，会按照参数出现的先后次序进行匹配，如果占位符{}指定了参数的序号，会按照序号替换对应参数。

• 使用键值对的关键字参数匹配

  #关键字参数
  print("{name} was born in {year},shi is {age} years old.".format(name='Lucy',age="20",year="2002"))
  #运行结果
  Lucy was born in 2002,shi is 20 years old.
  

• 使用序列的索引作为参数匹配

  #下标参数
  student=["Lcuy",20]
  school=("Jxau","jiangxi")
  print("{1[0]} was born in {0[1]},she is {1[1]} years old.".format(school,student))
  #运行结果
  Lcuy was born in jiangxi,she is 20 years old.
  

  如果format() 方法中的参数是列表或者元组，可以用其索引来匹配。

1.4字符串的比较

• 单字符串的比较

  两个单字符之间的比较都会转化为对应的ASCII码值之间的比较关系。

• 多字符字符串的比较

  • 从两个字符串中索引为0的位置开始比较。

  • 比较位于当前位置的两个单字符。

    如果两个字符相等，则两个字符串的当前索引加 1，回到步骤 (2) 开始;如果两个字符不相等，返回这两个字符的比较结果，作为字符串比较的结果。

  • 如果两个字符串到一个字符串结束时都相等，那么较长的字符串更大

• 字符串运算

  下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

  操作符	描述	实例
  +	字符串连接	a + b 输出结果： HelloPython
  *	重复输出字符串	a*2 输出结果：HelloHello
  []	通过索引获取字符串中字符	a[1] 输出结果 e
  [ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
  in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in a 输出结果 True
  not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in a 输出结果 True
  r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )

  #字符串输出
  a='hello'
  b='Python'
  print(a+b)
  print(a*2)
  print(a[1])
  print(a[1:4])#左闭右开
  #运行结果
  helloPython
  hellohello
  e
  ell
  

• 实验

  #字符串Python count（）方法
  #Python count 用于统计字符串里某个字符出现的次数
  str="this is string example...wow!!!"
  sub='i'
  print("str.count(sub,1,40)",str.count(sub,1,40))
  print("str.count(sub,4,40)",str.count(sub,4,40))
  sub="wow"
  print("str.count(sub):",str.count(sub))
  #运行结果
  str.count(sub,1,40) 3
  str.count(sub,4,40) 2
  str.count(sub): 1
  

  #字符串大小写转换的方法
  str1="hello,Python"
  print("str.lowers(str1):",str1.lower())
  print("str.upper(str1):",str1.upper())
  print("str.capitalize(str1):",str1.capitalize())
  print("str.swapcase(str1):",str1.swapcase())
  #运行结果
  str.lowers(str1): hello,python#lower：将string中的大写字符为小写
  str.upper(str1): HELLO,PYTHON#upper：将string中的小写字符为大写
  str.capitalize(str1): Hello,python#capitalize：将字符串的第一个字母变成大写,其他字母变小写。
  str.swapcase(str1): HELLO,pYTHON#swapcase:翻转字符串中的大小写
  

  #查找和替换函数
  str2="hello,Python"
  print(str2.find("hello"))
  print(str2.index("y"))
  print(str2.replace("hello","hi"))
  #运行结果
  0
  7
  hi,Python
  

  #例3-18字符串切片操作
  str2 =input('请输入一个字符串：')
  str_sum = 0
  dig_sum = 0
  spa_sum = 0
  other_sum = 0
  for strs in str2:
      if strs.isalpha():
          str_sum+=1
      elif strs.isdigit():
          dig_sum+=1
      elif strs == ' ':
          spa_sum+=1
      else:
          other_sum+=1
  
  print("该字符串中的字符有：",str_sum)
  print("该字符串中的数字有：",dig_sum)
  print("该字符串中的空格有：",spa_sum)
  print("该字符串中的特殊字符有：",other_sum)
  
  # 例3-19输入身份证号码输出对应的年月日
  ID= input('请输入十八位身份证号码：')
  if len(ID) == 18:
      print("你的身份证号码是"+ID)
  else:
      print("错误的身份证号码")
  year= ID[6:10]
  moon= ID[11:12]
  day= ID[12:14]
  print("出生年月:"+year+'年'+moon+'月'+day+'日')
  
  #3-20字符串的拆分与合并函数
  str3="hello,Python,hello,c!wjjw,sjsj,www,ww,q,w,w,w,w"
  print(str3.split())
  print(str3.split(","))
  print(str3.split(",",2))
  print(str3.split(",",3))
  lst=['hello','Python!','hello','c! ']
  s= " "
  print(s.join(lst))
  
  
  #例3-21字符串切片操作
  str1="hello,Python,hello,c!"
  print(str1[6:12])
  print(str1[-9:-2])#从倒数第8个往后索引到倒数第二个
  print(str1[3:-5])#从第3个索引到倒数第5个
  print(str1[:-3])#从第1个索引到索引为-3的字符串联
  print('java' in str1)
  print('Python' in str1)
  

2.Python的组合数据类型

Python除了整数类型、浮点类型等基本数据类型外，还提供了列表、元组、字典、集合等 组合数据类型。组合数据类型能将不同类型的数据组织在一起，实现复杂的数据表示或数据处理功能。

2.1列表

• 创建列表

列表是一种序列类型，标记为“[]”。序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。Python 有 6 个序列的内置类型，但最常见的是列表和元组。列表都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
#访问列表中的值
#与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
#通过索引列表可以进行截取、组合等操作。
list[2]:1997
list1[1:4]:['Runoob', 1997, 2000]
list1[1]:Runoob

• 删除列表

list1 = ['Google', 'Runoob', 1997, 2000]
print(list1)
del list1[1]
print(list1)
#运行结果
['Google', 'Runoob', 1997, 2000]
['Google', 1997, 2000]

• 修改列表元素

list1 = ['Google', 'Runoob', 1997, 2000]
print(list1)
list1[0]='HUAWEI'
print(list1)
#运行结果
['Google', 'Runoob', 1997, 2000]
['HUAWEI', 'Runoob', 1997, 2000]

• 读取列表元素

list1 = ['Google', 'Runoob', 1997, 2000]
print(list1[0])
print(list1[3])
print(list1[-1])
print(list1[-2])
print(list1[-4])
print(list1[4])
#运行结果
list1[0]：Google
list1[3]：2000
list1[-1]：2000
list1[-2]：1997
list1[-4]：Google
Traceback (most recent call last):
  File "D:/pycharm/py代码/Python期末/字符串比较.py", line 34, in <module>
    print(list1[4])
IndexError: list index out of range

第n个元素下标为n-1，超出list集合会报IndexError: list index out of range错误，除了正向读取外，还可以逆向读取，最后一个下表为-1。

• 列表截取与拼接

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]#输出索引1以后的所有元素
['Runoob', 'Taobao']
>>>

#列表还支持拼接操作：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

• 遍历列表

list1 = ['Google', 'Runoob', 1997, 2000]
result=[]
for i in range(len(list1)):
    result.append(list1[i])
print("result:",result)#和Java不同的是，这里不能够用加号连接起来
#运行结果
result: ['Google', 'Runoob', 1997, 2000]

#while循环遍历
list1 = ['Google', 'Runoob', 1997, 2000]
result=[]
i=0
while i<len(list1):
    result.append(list1[i])
    i=i+1
print("result:",result)
#运行结果
result: ['Google', 'Runoob', 1997, 2000]

• 列表方法

序号	函数
1	len(list)) 列表元素个数
2	max(list) 返回列表元素最大值
3	[in(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj 将对象插入列表
6	list.pop(index=-1)移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse()反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear清空列表
11	list.copy复制列表

#增加列表元素
list=[1]
list=list+['x','y']
print(list)
list.append(True)
print(list)
list.extend(['z',5])
print(list)

#运行结果
[1, 'x', 'y']
[1, 'x', 'y', True]
[1, 'x', 'y', True, 'z', 5]

2.2元组

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号 ( )，列表使用方括号 [ ]。
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup=()  #创建一个空元组

#创建元组
student=(1,"tom","2008-05-06",10,135.7)
num=(1,2,3,4,5,6,7)
tup=((1,2,3),(4,5),(6,7,8),9)
print("student[0]:",student[0])
print("num[1:5]:",num[1:5])
print("tup:",tup[2])
#运行结果
student[0]: 1
num[1:5]: (2, 3, 4, 5)
tup: (6, 7, 8)

• 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例

tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
#删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

• 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
#以上实例输出结果：
(12, 34.56, 'abc', 'xyz')

• 元组与列表的转换

#元组与列表的相互转换
tup1=(357,'abc','Python','xyz')
list1=list(tup1)
list1.append(246)#在列表末尾添加新的对象
tup1=tuple(list1)
print(list1)
print(tup1)
#以上实例输出结果：
[357, 'abc', 'Python', 'xyz', 246]
(357, 'abc', 'Python', 'xyz', 246)

• 元组运算符

与字符串、列表一样，元组之间可以使用+号和*进行运算。这就意味着他们可以组合和复制，运算后生成一个新的元组。

Python表达式	描述	结果
len((1,2,3))	计算元素个数	3
(1,2,3)+(4,5,6)	连接	(1,2,3,4,5,6)
(‘Hi!’,)*4	复制	(‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’)
3 in (1,2,3)	元素是否存在	True
for x in (1,2,3):print x	迭代	1 2 3

2.3字典

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

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。键必须是唯一的，但值则不必。

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))


#运行结果
{}
Length: 0
<class 'dict'>

#创建字典
dict1={}
dict2={'yuwen':88,'shuxue':75,'yingyu':96}
dict3=dict(yuwen=88,shuxue=75,yingyu=96)
dict4=dict([('yuwen',88),('shuxue',75),("yingyu",96)])
print(dict1)
print(dict2)
print(dict3)
print(dict4)

#运行结果
{}
{'yuwen': 88, 'shuxue': 75, 'yingyu': 96}
{'yuwen': 88, 'shuxue': 75, 'yingyu': 96}
{'yuwen': 88, 'shuxue': 75, 'yingyu': 96}

• 查找与反向查找字典元素

如果用字典里没有的键访问数据，会报错KeyError。

#查找字典元素
d1=dict({"id":19,"name":"marry","city":"chongqing"})
print(d1["city"])
print(d1["name"])
#运行结果
chongqing
marry

• 遍历字典

#遍历字典
d1=dict({"id":19,"name":"Zeyein","city":"chongqing"})
for key in d1.keys():
    print(key,d1[key])
#运行结果
id 19
name Zeyein
city chongqing

• 修改和添加字典元素

字典的大小和列表都是动态的，因此不需要事先指定其容量和大小，可以随时向字典中添加新的键值对，添加和修改的方法相同，都是使用“字典变量名[键名]=键值”的形式，字典中已有该键值对则为修改，没有则为添加。

dict1=dict({"sex":'female',"name":"Zeyein","city":"jian","id":2598})
#修改字典元素
dict1["id"]="2597"
print(dict1)
#添加字典元素
dict1["email"]="[email protected]"
print(dict1)
#运行结果
{'sex': 'female', 'name': 'Zeyein', 'city': 'jian', 'id': '2597'}
{'sex': 'female', 'name': 'Zeyein', 'city': 'jian', 'id': '2597', 'email': '[email protected]'}

• 检索字典元素

使用in运行符来测试某个特定的键是否在字典中。

#使用in运行符来检索
dict1=dict({"sex":'female',"name":"Zeyein","city":"jian","id":2598})
if "id" in dict1:
    print("键id存在")
else:
    print("键id不存在")

#运行结果
键id存在

• Python常用函数

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回一个视图对象
7	dict.keys() 返回一个视图对象
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 返回一个视图对象
11	dict.pop(key,default) 删除字典 key（键）所对应的值，返回被删除的值。
12	popitem() 返回并删除字典中的最后一对键和值。

2.5集合

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

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

创建格式：

parame = {value01,value02,...}
#或者
set(value)

#实例(Python 3.0+)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

• 创建集合

#没有参数，set会创建空集
nullSet=set()
print("nullSet=",nullSet)
#提供一个str作为输入集合，创建一个set
a_set=set("abcd")
print("a_set=",a_set)
#提供一个list作为输入集合，创建一个set
s=set([1,2,3])
print("s=",s)
#重复元素在set中自动被过滤
b=set([1,1,2,2,3,3,3])
print("b=",b)

#运行结果
nullSet= set()
a_set= {'d', 'a', 'b', 'c'}
s= {1, 2, 3}
b= {1, 2, 3}

• 删除集合元素

#删除集合元素
a=set(["y",'Python','b','o'])
print("a=",a)
a.remove("Python")
print("a=",a)
b=set(['b','h','o','n','p','t','y'])
print("b=",b)
b.discard('h')
print("b=",b)
c=set(['n','p','t','y'])
print("c=",c)
c.clear()
print("c=",c)
#运行结果
a= {'Python', 'b', 'o', 'y'}
a= {'b', 'o', 'y'}
b= {'y', 'n', 't', 'p', 'h', 'o', 'b'}
b= {'y', 'n', 't', 'p', 'o', 'b'}
c= {'n', 't', 'p', 'y'}
c= set()

删除集合元素有三种方法，其中remove删除集合元素不在集合中会报错，而discard删除的集合元素如果不在集合中不会报错，clear是删除集合中所有的元素。

• 添加集合元素

添加集合元素有两种方法，分别是add和update，能够重复添加， 但不会有效果。

add方法：把要传入的元素作为一个整体添加到集合中；

update方法：把要传入的元素拆分，作为个体添加到集合中。

#添加集合元素
a=set('boy')
a.add("python")
print('a=',a)
b=set('boy')
b.update("python")
print("b=",b)
#运行结果
a= {'o', 'b', 'python', 'y'}
b= {'y', 'p', 't', 'o', 'b', 'h', 'n'}

• 集合遍历

#集合的遍历
a=set('Python')
for x in a:
    print(x,end=" ")
#运行结果
t y h P n o #每次结果为随机

• 集合运算