python基础任务二（字符串、列表和元组）_在python交互式开发界面中验证字符串列表元组型数据的乘和加运算符的功能验证-CSDN博客

本文链接：https://blog.csdn.net/qq_42370261/article/details/88965736

一、字符串

1.创建字符串

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

创建字符串很简单，只要为变量分配一个值即可。

var1='apple'
var2='Hello World!'

2.访问字符串中的值

Python不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python访问子字符串，可以使用方括号来截取字符串。

var1='apple'
var2='Hello World!'
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

# var1[0]:  a
# var2[1:5]:  ello

3.字符串更新

字符串更新不能更改字符串里面的某一个字符，只能拼接。

var2='Hello World!'
print('更新后的var2：',var2[:6]+'Java!')

# 更新后的var2： Hello Java!

4.转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。

5.字符串运算符

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

下面代码实现：

a = "Hello"
b = "Python"
 
print ("a + b 输出结果：", a + b) 
print ("a * 2 输出结果：", a * 2) 
print ("a[1] 输出结果：", a[1]) 
print ("a[1:4] 输出结果：", a[1:4]) 
 
if("H" in a) :
    print ("H 在变量 a 中") 
else :
    print ("H 不在变量 a 中") 
 
if("M" not in a) :
    print ("M 不在变量 a 中") 
else :
    print ("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

# a + b 输出结果： HelloPython
# a * 2 输出结果： HelloHello
# a[1] 输出结果： e
# a[1:4] 输出结果： ell
# H 在变量 a 中
# M 不在变量 a 中
# \n
# \n

6.字符串格式化

a.常规格式化字符串

name='Crystal'
age=25
print("My name is %s,my age is %d." % (name,age))

# My name is Crystal,my age is 25.

python字符串格式化符号:

格式化操作符辅助指令：

b.格式化字符串函数format( )

格式化字符串函数str.format()，python2.6之后才有的。

基本语法是通过 {} 和：来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

print("{} {}".format("hello", "world"))    # 不设置指定位置，按默认顺序
# hello world
 
print("{0} {1}".format("hello", "world"))  # 设置指定位置
# hello world
 
print("{1} {0} {1}".format("hello", "world"))  # 设置指定位置
# world hello world

name='Crystal'
age=25
print("My name is {},my age is {}." .format(name,age))

可以设置参数

print("网站名：{name}, 地址 {url}".format(name="wyh_wen", url="https://blog.csdn.net/qq_42370261"))
 
# 通过字典设置参数
site = {"name": "wyh_wen", "url": "https://blog.csdn.net/qq_42370261"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数，"0" 是必须的
my_list = ['wyh_wen', 'https://blog.csdn.net/qq_42370261']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  

# 网站名：wyh_wen, 地址 https://blog.csdn.net/qq_42370261
# 网站名：wyh_wen, 地址 https://blog.csdn.net/qq_42370261
# 网站名：wyh_wen, 地址 https://blog.csdn.net/qq_42370261

也可以向 str.format() 传入对象：

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print(('value 为: {0.value}'.format(my_value)))  # "0" 是可选的

format( )数字格式化

下表展示了 str.format() 格式化数字的多种方法：

print('{:.2f}'.format(3.1415926))
# 3.14

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；（空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

我们可以使用大括号 {} 来转义大括号：

print ("{} 对应的位置是 {{0}}".format("python"))
# python 对应的位置是 {0}

7.三引号

python中三引号可以将复杂的字符串进行复制，允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。单引号里面字符串如果存在换行，则会报错。

hi='''hi,
i am here!'''
print(hi)

# 返回结果：
#  hi,
# i am here!

hi
# 'hi,\ni am here!'

8.字符串内建函数

二、列表

1.创建列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1=['bldg','unit',23,(84,79)]
print(list1)
list2=['zjpg','case','all']
print(list2)
list3=[25,87,46]
print(list3)

#返回结果
#['bldg', 'unit', 23, (84, 79)]
#['zjpg', 'case', 'all']
#[25, 87, 46]

2.访问列表中的值

使用下标索引来访问列表中的值

print('list1[0]:',list1[0])
print('list2[1]:',list2[1])
print('list3[0:2]:',list3[0:2])

#返回结果
#list1[0]: bldg
#list2[1]: case
#list3[0:2]: [25, 87]

3.基本操作符

print(len(list1))
print(list1+list2)
print(list2*3)
print(46 in list3)

# 4
# ['bldg', 23, (84, 79), 'one', 'zjpg', 'case', 'all']
# ['zjpg', 'case', 'all', 'zjpg', 'case', 'all', 'zjpg', 'case', 'all']
# True

4.列表截取

list2=list2*2
print(list2)
print(list2[3])
print(list2[-2])
print(list2[1:5])

# ['zjpg', 'case', 'all', 'zjpg', 'case', 'all']
# zjpg
# case
# ['case', 'all', 'zjpg', 'case']

5.python列表常见函数

（1）cmp(list1,list2) 比较两个列表的元素

如果比较的元素是同类型的,则比较其值,返回结果。

如果两个元素不是同一种类型,则检查它们是否是数字。

如果是数字,执行必要的数字强制类型转换,然后比较。
如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
否则,通过类型名字的字母顺序进行比较。

如果有一个列表首先到达末尾,则另一个长一点的列表"大"。

如果我们用尽了两个列表的元素而且所有元素都是相等的,那么结果就是个平局,就是说返回一个 0。

list1, list2 = [123, 'xyz'], [456, 'abc']
print cmp(list1, list2)
print cmp(list2, list1)
list3 = list2 + [786]
print cmp(list2, list3)

# -1
# 1
# -1

（2）len(llist) 列表元素个数

（3）max(list) 返回列表元素最大值

（4）min(list) 返回列表元素最小值

（5）list(seq) 将元组转化成列表

seq=(3,4,87,'abc')
print(list(seq))

# [3, 4, 87, 'abc']

（6）list1.append() 追加和更改替换列表元素

追加的元素是放在最后

#追加
list1.append('one')
print(list1)
#['bldg', 'unit', 23, (84, 79), 'one']

#更改替换
list3[2]='aaa'
print(list3)
#[25, 87, 'aaa']

（7）list.extend() 追加列表

该函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)
print ("Extended List : ", aList) 

# Extended List :  [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']


#注意区别以下三中方式
aList = [123, 'xyz', 'zara', 'abc', 123]
alist.append('one')
print(alist)
# [123, 'xyz', 'zara', 'abc', 123,'one']

aList = [123, 'xyz', 'zara', 'abc', 123]
alist.extend('one')
print(alist)
# [123, 'xyz', 'zara', 'abc', 123,'o','n','e']

aList = [123, 'xyz', 'zara', 'abc', 123]
alist.extend(['one'])
print(alist)
# [123, 'xyz', 'zara', 'abc', 123,'one']

（8）del list1 删除列表或者列表中的元素

list1.pop() 删除列表元素

del list1[1]
print(list1)
#['bldg', 23, (84, 79), 'one']

list.pop([index=-1]) 参数是要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

print(list1)
list1.pop()  #默认参数为-1
print(list1)
# ['bldg', 'unit', 23, (84, 79), 'one']
# ['bldg', 'unit', 23, (84, 79)]

a=list1.pop(1)  
print(list1)
print(a)
# ['bldg', 23, (84, 79)]
# 'unit'

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

aList = [123, 'xyz', 'zara', 'abc', 123]
print ("Count for 123 : ", aList.count(123))
print ("Count for zara : ", aList.count('zara'))

（10）list.index() 返回位置

函数用于从列表中找出某个值第一个匹配项的索引位置。该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

aList = [123, 'xyz', 'zara', 'abc','xyz']
print ("Index for xyz : ", aList.index( 'xyz' )) 
print ("Index for zara : ", aList.index( 'zara' ))

# Index for xyz :  1
# Index for zara :  2

（11）list.insert() 在指定位置插入指定对象

insert() 函数用于将指定对象插入列表的指定位置。

list.insert(index, obj) index是指定位置，obj是指定对象

aList = [123, 'xyz', 'zara', 'abc']
aList.insert( 3, 2009)
print ("Final List : ", aList)

# Final List :  [123, 'xyz', 'zara', 2009, 'abc']

（12）list.remove() 移除元素

remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除列表中的某个值的第一个匹配项。

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.remove('xyz')
print ("List : ", aList)
aList.remove('abc')
print ("List : ", aList)

# List :  [123, 'zara', 'abc', 'xyz']
# List :  [123, 'zara', 'xyz']

（13）list.reverse() 反向排序列表元素

reverse() 函数用于反向排序列表中元素。该方法没有返回值，但是会对列表的元素进行反向排序。

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()
print ("List : ", aList)

# List :  ['xyz', 'abc', 'zara', 'xyz', 123]

（14）list.sort() 排序

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

list.sort(cmp=None, key=None, reverse=False) reverse=False默认升序，True降序。

该方法没有返回值，但是会对列表的对象进行排序。

aList = ['123', 'Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort()
print ("List : ", aList)
# List :  ['123', 'Facebook', 'Google', 'Runoob', 'Taobao']

#降序
vowels = ['e', 'a', 'u', 'o', 'i']
vowels.sort(reverse=True)
print ('降序输出:', vowels)
# 降序输出: ['u', 'o', 'i', 'e', 'a']

#指定排序元素
def takeSecond(elem):
    return elem[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond)  # 指定第二个元素排序
print ('排序列表：', random)
# 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

（15）list.clear() 清除列表所有元素

ls = [1,2,3,"4",5,"a"]
ls.clear() #删除列表中的所有元素。
print(ls.clear()) #无返回值
print(ls) #返回的ls为空列表。

# None
# []

（16）list.copy() 复制列表（浅层复制）

ls = [1,2,3,[4,5,6]]
lt = ls.copy() #lt复制ls中的所有元素
ls.clear() #删除ls所有元素，lt中的元素没有被删除。
lk = ls #这不是复制，而是给列表ls新关联一个引用，即增加一个别名，ls和lt指向同一个内存地址。
print(id(ls),id(lk))
print(lt)
print(ls)

# 1820579702152 1820579702152
# [1, 2, 3, [4, 5, 6]]
# []

无论是修改原列表ls的内嵌套列表的元素，还是修改复制列表lt的内嵌套列表元素。列表ls和列表lt的内嵌套列表元素都将改变。

但修改列表ls或列表lt的其它非嵌套元素，都不改变对方相应的元素。

ls = [1,2,3,[4,5,6]]
lt = ls.copy() #lt复制ls中的所有元素
ls[0] = "a" #对变列表ls中的第一个元素进行修改
ls[3][0] = "a" #对列表ls中第四个元素的第一个元素进行修改
print(lt) #列表lt的第一个元素不变，但第四个元素的第一个元素发生改变。
print(ls)

# [1, 2, 3, ['a', 5, 6]]
# ['a', 2, 3, ['a', 5, 6]]

ls = [1,2,3,[4,5,6]]
lt = ls.copy()
lt[0] = "a" #对变列表lt中的第一个元素进行修改
lt[3][0] = "a" #对列表lt中第四个元素的第一个元素进行修改
print(lt)
print(ls) #列表ls的第一个元素不变，但第四个元素的第一个元素发生改变。

# ['a', 2, 3, ['a', 5, 6]]
# [1, 2, 3, ['a', 5, 6]]

深层复制方法

import copy
ls = [1,2,3,[7,"b",9],"a"]
lt1 = copy.deepcopy(ls) #深层复制。
lt2 = copy.copy(ls) #浅层复制
ls[3][1] = "abc123" #改变原列表ls中内嵌套列表[7,"b",9] 中的“b”元素。深层复制的lt1列表对应位置元素不改变，但浅层复制改变。
print(ls)
print("深层复制：",lt1)
print("浅层复制：",lt2)

# [1, 2, 3, [7, 'abc123', 9], 'a']
# 深层复制： [1, 2, 3, [7, 'b', 9], 'a']
# 浅层复制： [1, 2, 3, [7, 'abc123', 9], 'a']

三、元组

1.创建元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1=('Java','Python','R')
tup2=(1,2,5,6,9)
tup3='a','b','d'
print(tup1)
print(tup2)
print(tup3)

# ('Java', 'Python', 'R')
# (1, 2, 5, 6, 9)
# ('a', 'b', 'd')

tup4=()
tup5=(8,)  #一个元素时需要加“，”，否则输出不是元组
tup6=(8)
print(tup4)
print(tup5)
print(tup6)

# ()
# (8,)
# 8

2.访问元组

元组可以使用下标索引来访问元组中的值。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

# tup1[0]:  physics
# tup2[1:5]:  (2, 3, 4, 5)

3.改变元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# tup1[0] = 100，该操作不对
tup3 = tup1 + tup2
print (tup3)

# (12, 34.56, 'abc', 'xyz')

4.删除元组

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

#删除tup后，tup不存在了
del tup

5.元组运算符

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

6.元组索引、截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素。

tup7=('java','python','mysql','r','oracle')
print(tup7[1])
print(tup7[-1])
print(tup7[1:4])

# python
# oracle
# ('python', 'mysql', 'r')

7.无关闭分隔符

tup3='a','b','d'
print(tup3)

# ('a', 'b', 'd')

8.元组内置函数