字符串
1.字符串的定义
字符串被定义为引号之间的字符集合 Python 支持使用成对的单引号'
或双引号"
str1 = 'Hello World!'
print ( str1, type ( t1) )
str2 = "Hello World!"
print ( str1, type ( t1) )
print ( 5 + 8 )
print ( '5' + '8' )
转义字符 描述 \ (在行尾时) 续行符 \ 反斜杠符号 ’ 单引号 " 双引号 \a 响铃 \b 退格(Backspace) \e 转义 \000 空 \n 换行 \v 纵向制表符 \t 横向制表符 \r 回车 \f 换页 \oyy 八进制数,yy代表的字符,例如:\o12代表换行 \xyy 十六进制数,yy代表的字符,例如:\x0a代表换行 \other 其它的字符以普通格式输出
如果字符串中需要出现单引号或双引号,可以使用转义符号\对字符串中的符号进行转义
print ( 'let\'s go' )
print ( "let's go" )
print ( 'C:\\now' )
print ( "C:\\Program Files\\Intel\\Wifi\\Help" )
原始字符串只需要在字符串前边加一个英文字母 r 即可
print ( r'C:\Program Files\Intel\Wifi\Help' )
三引号
允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print ( para_str)
para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print ( para_str)
2.字符串的切片与拼接
类似于元组具有不可修改性 索引从0
开始 (和Java
一样) 切片通常写成start:end
这种形式,包括start索引
对应的元素,不包括end索引
对应的元素 索引值可正可负,正索引
从0
开始,从左往右;负索引
从-1
开始,从右往左 使用负数索引时,会从最后一个元素开始计数,最后一个元素的位置编号是-1
num_str = '123456789'
num_str_1 = num_str[ 2 : 6 ]
print ( num_str_1)
num_str_1 = num_str[ 2 : ]
print ( num_str_1)
num_str_1 = num_str[ 0 : - 5 ]
print ( num_str_1)
num_str_1 = num_str[ : ]
print ( num_str_1)
num_str_1 = num_str[ : : 2 ]
print ( num_str_1)
num_str_1 = num_str[ - 2 : ]
print ( num_str_1)
num_str_1 = num_str[ : : - 1 ]
3.字符串的常用内置方法
capitalize()
将字符串的第一个字符转换为大写
str1 = 'this is an example of a string'
print ( str1. capitalize( ) )
lower()
转换字符串中所有大写字符为小写upper()
转换字符串中的小写字母为大写swapcase()
将字符串中大写转换为小写,小写转换为大写
'Nice To SEE YOU' . lower( )
'Nice To SEE YOU' . upper( )
'Nice To SEE YOU' . swapcase( )
count(str, beg= 0,end=len(string))
返回str
在string
里面出现的次数,如果beg
或者end
指定则返回指定范围内str
出现的次数
'nice to meet you' . count( 'o' )
'nice to meet you' . count( 'o' , 8 )
'nice to meet you' . count( 'o' , 8 , 10 )
endswith(suffix, beg=0, end=len(string))
检查字符串是否以指定子字符串suffix
结束,如果是,返回True
,否则返回False
。如果beg
和end
指定值,则在指定范围内检查startswith(substr, beg=0,end=len(string))
检查字符串是否以指定子字符串substr
开头,如果是,返回True
,否则返回False
。如果 beg 和 end 指定值,则在指定范围内检查
'nice to meet you' . endswith( 'you' )
'nice to meet you' . endswith( 'meet' , 2 , 12 )
'nice to meet you' . startswith( 'nice' )
'nice to meet you' . startswith( 'meet' , 8 , 15 )
find(str, beg=0, end=len(string))
检测str
是否包含在字符串中,如果指定范围beg
和end
,则检查是否包含在指定范围内,如果包含,返回开始的索引值,否则返回-1
rfind(str, beg=0,end=len(string))
类似于find()
函数,不过是从右边开始查找
'nice to meet you' . find( 'me' )
'nice to meet you' . find( 'to' , 6 )
isnumeric()
如果字符串中只包含数字字符,则返回True
,否则返回False
'12345' . isnumeric( )
ljust(width[, fillchar])
返回一个原字符串左对齐,并使用fillchar
(默认空格)填充至长度width
的新字符串rjust(width[, fillchar])
返回一个原字符串右对齐,并使用fillchar
(默认空格)填充至长度width
的新字符串
'1101' . ljust( 8 , '0' )
'1101' . rjust( 8 , '0' )
lstrip([chars])
截掉字符串左边的空格或指定字符rstrip([chars])
删除字符串末尾的空格或指定字符strip([chars])
在字符串上执行lstrip()
和rstrip()
'www.10086.cn' . lstrip( 'wcn.' )
'www.10086.cn' . rstrip( 'wcn.' )
'www.10086.cn' . strip( 'wcn.' )
partition(sub)
找到子字符串sub
,把字符串分为一个三元组(pre_sub
,sub
,fol_sub
),如果字符串中不包含sub则返回(‘原字符串’,’’,’’)rpartition(sub)
类似于partition()
方法,不过是从右边开始查找
'www.10086.cn' . partition( '10086' )
'www.10086.cn' . partition( '10087' )
replace(old, new [, max])
把字符串中的old
替换成new
,如果max
指定,则替换不超过max
次
'Hello, World. Nice to see you!' . replace( 'o' , '*' )
split(str='', num)
不带参数默认是以空格为分隔符切片字符串,如果num
参数有设置,则仅分隔num
个子字符串,返回切片后的子字符串拼接的列表
'we are family' . split( )
'we are family' . split( ' ' )
u = "www.baidu.com.cn"
print ( u. split( ) )
print ( ( u. split( '.' ) ) )
print ( ( u. split( "." , 0 ) ) )
print ( ( u. split( "." , 1 ) ) )
print ( u. split( "." , 2 ) )
print ( ( u. split( "." , 2 ) [ 1 ] ) )
u1, u2, u3 = u. split( "." , 2 )
print ( u1)
print ( u2)
print ( u3)
c = '''say
hello
baby'''
print ( c. split( '\n' ) )
string = "hello boy<[www.baidu.com]>byebye"
print ( string. split( '[' ) [ 1 ] . split( ']' ) [ 0 ] )
print ( string. split( '[' ) [ 1 ] . split( ']' ) [ 0 ] . split( '.' ) )
splitlines([keepends])
按照行(’\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数keepends
为False
,不包含换行符,如果为True
,则保留换行符
'Nice \r\n to \r see \n you' . splitlines( )
'Nice \r\n to \r see \n you' . splitlines( True )
maketrans(intab, outtab)
创建字符映射的转换表,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标translate(table, deletechars="")
根据参数table给出的表,转换字符串的字符,要过滤掉的字符放到deletechars
参数中
str = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str . maketrans( intab, outtab)
print ( trantab)
print ( str7. translate( trantab) )
4.字符串格式化
str = "{0} Love {1}" . format ( 'I' , 'Lsgogroup' )
print ( str )
str = "{a} Love {b}" . format ( a= 'I' , b= 'Lsgogroup' )
print ( str )
str = "{0} Love {b}" . format ( 'I' , b= 'Lsgogroup' )
print ( str )
str = '{0:.2f}{1}' . format ( 27.658 , 'GB' )
print ( str )
符号 描述 %c 格式化字符及其ASCII码 %s 格式化字符串 %d 格式化整数 %u 格式化无符号整型 %o 格式化无符号八进制数 %x 格式化无符号十六进制数 %X 格式化无符号十六进制数(大写) %f 格式化浮点数字,可指定小数点后的精度 %e 用科学计数法格式化浮点数 %E 作用同%e,用科学计数法格式化浮点数 %g %f和%e的简写 %G %f 和 %E 的简写 %p 用十六进制数格式化变量的地址
符号 功能 m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) - 用作左对齐 + 在正数前面显示加号( + ) # 在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) 0 显示的数字前面填充’0’而不是默认的空格
print ( '%5.1f' % 27.658 )
print ( '%.2e' % 27.658 )
print ( '%10d' % 10 )
print ( '%-10d' % 10 )
print ( '%+d' % 10 )
print ( '%#o' % 10 )
print ( '%#x' % 108 )
print ( '%010d' % 5 )
字典
1.可变类型与不可变类型
序列是以连续的整数为索引,与此不同的是,字典以"关键字"为索引,关键字可以是任意不可变类型,通常用字符串或数值 字典是Python唯一
的一个映射类型
,字符串、元组、列表属于序列类型
那么如何快速判断一个数据类型X
是不是可变类型的呢?两种方法:
麻烦方法:用d(X)
函数,对X
进行某种操作,比较操作前后的id
,如果不一样,则X
不可变,如果一样,则X
可变 便捷方法:用hash(X)
,只要不报错,证明X
可被哈希,即不可变,反过来不可被哈希,即可变
i = 1
print ( id ( i) )
i = i + 2
print ( id ( i) )
l = [ 1 , 2 ]
print ( id ( l) )
l. append( 'Python' )
print ( id ( l) )
整数i
在加1
之后的id
和之前不一样,因此加完之后的这个i
(虽然名字没变),但不是加之前的那个i
了,因此整数是不可变类型 列表l
在附加 ‘Python’ 之后的id
和之前一样,因此列表是可变类型
print ( hash ( 'Name' ) )
print ( hash ( ( 1 , 2 , 'Python' ) ) )
print ( hash ( [ 1 , 2 , 'Python' ] ) )
print ( hash ( { 1 , 2 , 3 } ) )
数值、字符和元组 都能被哈希,因此它们是不可变类型 列表、集合、字典不能被哈希,因此它是可变类型
2.字典的定义
字典是无序的
键:值(key:value)对集合,键必须是互不相同的(在同一个字典之内)
dict
内部存放的顺序和key
放入的顺序是没有关系的dict
查找和插入的速度极快,不会随着key
的增加而增加,但是需要占用大量的内存
字典定义语法为 {元素1, 元素2, ..., 元素n}
其中每一个元素是一个「键值对」-- 键:值 (key:value) 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」 大括号 – 把所有元素绑在一起 逗号 – 将每个键值对分开 冒号 – 将键和值分开
3.创建和访问字典
brand = [ '李宁' , '耐克' , '阿迪达斯' ]
slogan = [ '一切皆有可能' , 'Just do it' , 'Impossible is nothing' ]
print ( '耐克的口号是:' , slogan[ brand. index( '耐克' ) ] )
dic = { '李宁' : '一切皆有可能' , '耐克' : 'Just do it' , '阿迪达斯' : 'Impossible is nothing' }
print ( '耐克的口号是:' , dic[ '耐克' ] )
dic1 = { 1 : 'one' , 2 : 'two' , 3 : 'three' }
print ( dic1)
print ( dic1[ 1 ] )
print ( dic1[ 4 ] )
dic2 = { 'rice' : 35 , 'wheat' : 101 , 'corn' : 67 }
print ( dic2)
print ( dic2[ 'rice' ] )
注意:如果我们取的键在字典中不存在,会直接报错KeyError。
dic = { ( 1 , 2 , 3 ) : "Tom" , "Age" : 12 , 3 : [ 3 , 5 , 7 ] }
print ( dic)
print ( type ( dic) )
通过构造函数dict
来创建字典 dict()
函数用来创建一个空的字典通过key
直接把数据放入字典中,但一个key
只能对应一个value
,多次对一个key放入value
,后面的值会把前面的值冲掉
class dict ( ** kwarg)
class dict ( mapping, ** kwarg)
class dict ( iterable, ** kwarg)
** kwargs - - 关键字
mapping - - 元素的容器
iterable - - 可迭代对象
dic = dict ( )
dic[ 'a' ] = 1
dic[ 'b' ] = 2
dic[ 'c' ] = 3
print ( dic)
dic[ 'a' ] = 11
print ( dic)
dic[ 'd' ] = 4
print ( dic)
dict ( a= 'a' , b= 'b' , t= 't' )
dict ( zip ( [ 'one' , 'two' , 'three' ] , [ 1 , 2 , 3 ] ) )
dict ( [ ( 'one' , 1 ) , ( 'two' , 2 ) , ( 'three' , 3 ) ] )
4.字典的内置方法
dict.fromkeys(seq[, value])
用于创建一个新字典,以序列seq
中元素做字典的键,value
为字典所有键对应的初始值
seq = ( 'name' , 'age' , 'sex' )
dic1 = dict . fromkeys( seq)
print ( dic1)
dic2 = dict . fromkeys( seq, 10 )
print ( dic2)
dic3 = dict . fromkeys( seq, ( '小马' , '8' , '男' ) )
print ( dic3)
dict.keys()
返回一个可迭代对象,可以使用list()
来转换为列表,列表为字典中的所有键
dic = { 'Name' : 'lsgogroup' , 'Age' : 7 }
print ( dic. keys( ) )
lst = list ( dic. keys( ) )
print ( lst)
dict.values()
返回一个迭代器,可以使用list()
来转换为列表,列表为字典中的所有值
dic = { 'Sex' : 'female' , 'Age' : 7 , 'Name' : 'Zara' }
print ( dic. values( ) )
print ( list ( dic. values( ) ) )
dict.items()
以列表返回可遍历的 (键
, 值
) 元组数组
dic = { 'Name' : 'Lsgogroup' , 'Age' : 7 }
print ( dic. items( ) )
print ( tuple ( dic. items( ) ) )
print ( list ( dic. items( ) ) )
dict.get(key, default=None)
返回指定键的值,如果值不在字典中返回默认值
dic = { 'Name' : 'Lsgogroup' , 'Age' : 27 }
print ( "Age 值为 : %s" % dic. get( 'Age' ) )
print ( "Sex 值为 : %s" % dic. get( 'Sex' , "NA" ) )
print ( dic)
dict.setdefault(key, default=None)
和get()
方法类似, 如果键不存在于字典中,将会添加键并将值设为默认值
dic = { 'Name' : 'Lsgogroup' , 'Age' : 7 }
print ( "Age 键的值为 : %s" % dic. setdefault( 'Age' , None ) )
print ( "Sex 键的值为 : %s" % dic. setdefault( 'Sex' , None ) )
print ( dic)
key in dict in
操作符用于判断键是否存在于字典中,如果键在字典dict
里返回true
,否则返回false
。而not in
操作符刚好相反,如果键在字典dict
里返回false
,否则返回true
dic = { 'Name' : 'Lsgogroup' , 'Age' : 7 }
if 'Age' in dic:
print ( "键 Age 存在" )
else :
print ( "键 Age 不存在" )
if 'Sex' in dic:
print ( "键 Sex 存在" )
else :
print ( "键 Sex 不存在" )
if 'Age' not in dic:
print ( "键 Age 不存在" )
else :
print ( "键 Age 存在" )
dict.pop(key[,default])
删除字典给定键key
所对应的值,返回值为被删除的值。key
值必须给出。若key
不存在,则返回default
值del dict[key]
删除字典给定键key
所对应的值
dic1 = { 1 : "a" , 2 : [ 1 , 2 ] }
print ( dic1. pop( 1 ) , dic1)
print ( dic1. pop( 3 , "nokey" ) , dic1)
del dic1[ 2 ]
print ( dic1)
dict.popitem()
随机返回并删除字典中的一对键和值,如果字典已经为空,却调用了此方法,就报出KeyError
异常
dic1 = { 1 : "a" , 2 : [ 1 , 2 ] }
print ( dic1. popitem( ) )
print ( dic1)
dic = { 'Name' : 'Zara' , 'Age' : 7 }
print ( "字典长度 : %d" % len ( dic) )
dic. clear( )
print ( "字典删除后长度 : %d" % len ( dic) )
dic1 = { 'Name' : 'Lsgogroup' , 'Age' : 7 , 'Class' : 'First' }
dic2 = dic1. copy( )
print ( "dic2" )
dic1 = { 'user' : 'lsgogroup' , 'num' : [ 1 , 2 , 3 ] }
dic2 = dic1
dic3 = dic1. copy( )
print ( id ( dic1) )
print ( id ( dic2) )
print ( id ( dic3) )
dic1[ 'user' ] = 'root'
dic1[ 'num' ] . remove( 1 )
print ( dic1)
print ( dic2)
print ( dic3)
dict.update(dict2)
把字典参数dict2
的key:value对
更新到字典dict
里
dic = { 'Name' : 'Lsgogroup' , 'Age' : 7 }
dic2 = { 'Sex' : 'female' , 'Age' : 8 }
dic. update( dic2)
print ( dic)