Python学习week4-python元组与字符串

1、python数据结构之元组

1.1、元组特点

（1）元组特点：有序，不可变；可以理解为不可变的列表；

（2）元组与列表的不同：

　# 元组tuple，可hash，不可变数据类型，()表示；一般元组用来存储结构化数据，一般每个字段的意义不同；　

import time
print(time.localtime())
'''
(tm_year=2018, tm_mon=8, tm_mday=15, tm_hour=10, tm_min=40, tm_sec=4, tm_wday=2, tm_yday=227, tm_isdst=0)
'''

　# 列表list，不可hash，可变数据类型，[]表示；一般列表存储的是同类型的顺序数据；

l=list(range(6))
print(l)
'''
[0, 1, 2, 3, 4, 5]
'''

1.2、元组的定义与初始化

（1）元组的定义：

　　tuple() -> empty tuple

　　tuple(iterable) -> tuple initialized from iterable's items

　　t=tuple()  # 工厂方法

　　t=() # 定义一个空元组

　　t=tuple(range(5))

　　t=(1,)  # 定义一个元素的元组的时候一定记住后面跟一个逗号，否则定义的不是元组；

t1=(1)
t2=(1,)
print(type(t1),type(t2))
'''
<class 'int'> <class 'tuple'>
'''

1.3、元组的访问

# 元组的访问跟列表的访问方法一样，都是通过索引访问；

1.4、元组的查询

（1）index(value,[start,[stop])

　　通过值value，从指定区间查找元组内的元素是否匹配；

　　匹配到一个就返回索引；

　　匹配不到抛出异常valueError；

（2）count(value)

　　返回元组内匹配到value值的次数

# index和count的时间复杂度都是O（n），随着n的规模增大，效率越低；

2、python 字符串

2.1、字符串的定义与初始化

（1）字符串特点：有序可索引，可迭代，不可变数据类型；

（2）字符串定义与初始化：

class str(object):
    """
    str(object='') -> str
    str(bytes_or_buffer[, encoding[, errors]]) -> str
例如：
　　s1='hello world'
　　s2="I'm jerry"   # 注意：如果内层有引号，则外层必须用不一样的；
　　s3=r'hello 
 world'  # 前面加r表示里面的所有字符都不做特殊处理

2.2、字符串连接

（1）字符串join连接

    def join(self, iterable): # real signature unknown; restored from __doc__
        """
        S.join(iterable) -> str
        
        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.  # 元素之间的分隔符是S
        """
        return ""
# 将可迭代对象连接起来，使用S作为分隔符;
# 返回一个新的字符串；
# 例如： str=‘hello’ ==>'@'.join(str) ==> h@e@l@l@o

（2）字符串'+'连接

# '+'将2个字符串连接在一起，返回一个新的字符串；本质上'+'调用的是__add__方法；

2.3、字符串分割

# 字符串的分割分为2中方法：

（1）split(sep=None, maxsplit=-1)

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings
        
        Return a list of the words in S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are
        removed from the result.
        """
        return []
# 从左至右，按照分隔符sep进行切分；
# 'sep=', 指定分隔符，默认空白字符串作为分隔符；
# 'maxsplit=',可以指定最大分割次数，如果不指定则遍历所有字符串进行分割；

str1='helloler'
lst1=str1.split('l',1) # 最大分割默认==>['he', 'loler']
lst2=str1.split('l') # ==> 最大分割1次['he', '', 'o', 'er']

# rsplit：从右至左分割；

s='00100110'
print(s.rsplit('0',1))
'''
['0010011', '']
'''

（2）partition(self, sep) ， sep分隔符必须指定；

    def partition(self, sep): # real signature unknown; restored from __doc__
        """
        S.partition(sep) -> (head, sep, tail) # 根据分隔符分成三部分（一刀两断），返回一个tuple；
        
        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.
        """
# 从左至右进行分割，遇到分隔符就把字符串分割成两部分，返回头部，分隔符，尾部组成的三元组；
# 如果没有找到分隔符，则返回字符串整体（头部），2个空元素的三元组；
# rpartition，从右至左开始切；

str1='helloler'
lst3=str1.partition('l') 　# ==>('he', 'l', 'loler') <class 'tuple'>
lst4=str1.rpartition('l')  # ==>('hello', 'l', 'er')
print(lst3)
print(lst4)
'''
('hello', 'l', 'er')
('he', 'l', 'loler')
'''

2.4、字符串大小写

# str.upper()  全大写

# str.lower()  全小写

2.5、字符串排版

str1='hello ,world'

print(str1.title()) # 标题字符大写
'''
Hello ,World
'''
print(str1.center(20,'#')) # 宽度20个字符,str1居中打印,空白用#填充
'''
####hello ,world####
'''
print(str1.zfill(20)) # 宽度20,右对齐，空白字符用0填充
'''
00000000hello ,world
'''
print(str1.rjust(20,'@')) # 宽度20，右对齐,空白字符用@填充
'''
@@@@@@@@hello ,world
'''
print(str1.ljust(20,'@')) # 宽度20，左对齐，空白字符用@填充
'''
hello ,world@@@@@@@@
'''

2.6、字符串的修改

# 由于字符串是不可变数据类型，不能修改，这里的修改都是修改后返回新的字符串（原来字符串没有改变）；

（1）replace(old,new[,count])  ==> new str

    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str
        
        Return a copy of S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""
例如：

str1='hello ,world'
s=str1.replace('l','G',2) # 将字符串str1中的l替换为G，只替换1次；
print(s) # ==> heGGo ,world

 （2）strip([chars]) ==> new str

# 从字符串的两端去除指定字符集chars中的所有字符；

# 如果chars没有被指定，则去除两端的空白字符；

# lstrip 从左边开始；

# rstrip 从右边开始；

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.strip([chars]) -> str
        
        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

2.7、字符串的查找与判断

## 字符串的查找

（1）find(sub[,start[,end]])  ==> int

# 在指定区间，从左至右，查找子串sub，找到立即返回索引，没找到返回-1；

（2）index(sub,[,start[,end]]) ==> int 

# 类似于通过value查找索引号；

## 字符串的判断

（1）endswith(suffix,[,start[,end]])  ==>bool

# 在指定区间，字符串是否以suffix（词尾）结尾；

（2）startswith(prefix,[,start[,end]])  ==>bool

# 在指定区间，字符串是否以prefix（词首）开头；

## 字符串判断is系列

2.8、字符串格式化

# python中的格式化输入有2种：printf 风格和format（推荐使用）

（1）printf-style formatting，来自于c语言的风格

　　格式要求：

• 占位符：使用%和格式字符串组成，例如%s，%d等
• 占位符中可以插入修饰符，例如%03d表示，打印3个位置，不够前面补0；
• format % value,格式化字符串和被格式的值之间使用%分隔，如果要打印%则用%%
• vaule只能是一个对象，或者是一个和格式化字符串占位符数目相等的元组，或一个字典　　　　　　

print('my name is %s,my age is %03d, %d%% ' %('jerry',18,10))
'''
my name is jerry,my age is 018, 10% 
'''

（2）format(*args,**kwargs)

• "{}{xxx}".format(*args,**kwargs) ==> str
• args是位置参数，接受一个元组；
• **kwargs是关键字参数，接受一个字典；
• 花括号表示占位符
• {}表示按照顺序匹配位置参数，{n}表示取位置参数的索引为n的值；

print("{}{}".format('192.168.19.1',':8080')) # ==>192.168.19.1:8080
# args=('192.168.19.1','8080')

print("{server}{1}{0}".format(':8080','192.168.10.1',server='webserverIP:'))
# ==> webserverIP:192.168.10.1:8080
# args=('192.168.19.1','8080'), kwargs={server:'webserverIP:'}

print("{0[0]}is:{1[1]}:{0[1]}".format(('hello','world'),('19','20')))
# hellois:20:world
# 0=args=('hello','world') args[0]='hello' args[1]='world'
# 1=args=('19','20')

from collections import namedtuple
Piont=namedtuple('p','x y')
p=Piont(4,5)

print("{0.x}:{0.y}".format(p))
# ==> 4:5

print("{:#^30}".format('hello world')) # 长度为30个字符，居中，其他以#填充
'''
运行结果：#########hello world##########
'''
print("{:#>30}".format('hello world')) # 右对齐
'''
运行结果：###################hello world
'''
print("{:#<30}".format('hello world')) # 左对齐
'''
运行结果：hello world###################
'''
print("{:.2f}".format(1.34221)) # 通常都是配合 f 使用,其中.2表示长度为2的精度，f表示float类型
'''
运行结果:1.34
'''
print('{:,}'.format(9987733498273.0432))
'''
运行结果：9,987,733,498,273.043
'''
print("{:b}".format(10)) # 1010 二进制
print("{:o}".format(10)) # 12 八进制
print("{:x}".format(10)) # a 十六进制