python 字符串%和format_python基础任务二

一、字符串

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

也可以向 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）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'

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

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

（9）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']

（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.元组内置函数