Python内置数据结构

字符串

一个个字符组成的有序的序列，是字符的集合
使用单引号、双引号、三引号引住的字符序列
字符串是不可变对象
Python3起，字符串就是Unicode类型

字符串定义 初始化

s1 = ‘string’
s2 = “string2”
s3 = ‘’‘this’s a “String” ‘’’
s4 = ‘hello \n baidu.com’
s5 = r"hello \n baidu.com"
s6 = ‘c:\windows\nt’
s7 = R"c:\windows\nt"
s8 = ‘c:\windows\nt’
sql = “”“select * from user where name=‘tom’ “””

字符串元素访问——下标

字符串支持使用索引访问
sql = “select * from user where name=‘tom’”
sql[4] # 字符串’c’
sql[4] = ‘o’
有序的字符集合，字符序列
for c in sql:
print©
print(type©) # 什么类型？
可迭代
lst = list(sql)

字符串join连接*

“string”.join(iterable) -> str
将可迭代对象连接起来，使用string作为分隔符
可迭代对象本身元素都是字符串
返回一个新字符串
lst = [‘1’,‘2’,‘3’]
print(""".join(lst)) # 分隔符是双引号
print(" “.join(lst))
print(”\n".join(lst))
lst = [‘1’,[‘a’,‘b’],‘3’]
print(" ".join(lst))

字符串+连接

(+) -> str
将2个字符串连接在一起
返回一个新字符串

字符串分割

分割字符串的方法分为2类
split系
将字符串按照分隔符分割成若干字符串，并返回列表
partition系
将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
split(sep=None, maxsplit=-1) -> list of strings
从左至右
sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit 指定分割的次数，-1 表示遍历整个字符串

s1 = "I'm \ta super student."
s1.split()
s1.split('s')
s1.split('super')
s1.split('super ')
s1.split(' ')
s1.split(' ',maxsplit=2)
s1.split('\t',maxsplit=2)

rsplit(sep=None, maxsplit=-1) -> list of strings
从右向左
sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit 指定分割的次数，-1 表示遍历整个字符串

s1 = "I'm \ta super student."
s1.rsplit()
s1.rsplit('s')
s1.rsplit('super')
s1.rsplit('super ')
s1.rsplit(' ')
s1.rsplit(' ',maxsplit=2)
s1.rsplit('\t',maxsplit=2)

partition(sep) -> (head, sep, tail)
从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果
没有找到分隔符，就返回头、2个空元素的三元组
sep 分割字符串，必须指定

rpartition(sep) -> (head, sep, tail)
从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果
没有找到分隔符，就返回2个空元素和尾的三元组

字符串大小写

upper()
全大写
lower()
全小写
大小写，做判断的时候用
swapcase()
交互大小写

字符串修改*

replace(old, new[, count]) -> str
字符串中找到匹配替换为新子串，返回新字符串
count表示替换几次，不指定就是全部替换

strip([chars]) -> str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去除两端的空白字符

字符串查找*

find(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1

index(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError

len(string)
返回字符串的长度，即字符的个数

count(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，统计子串sub出现的次数

字符串判断 is系列

isalnum() -> bool 是否是字母和数字组成
isalpha() 是否是字母
isdecimal() 是否只包含十进制数字
isdigit() 是否全部数字(0~9)
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
islower() 是否都是小写
isupper() 是否全部大写
isspace() 是否只包含空白字符

#字符串格式化
format函数格式字符串语法

“{} {xxx}”.format(*args, **kwargs) -> str
args是位置参数，是一个元组
kwargs是关键字参数，是一个字典
花括号表示占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}} 表示打印花括号

位置参数

“{}:{}”.format(‘192.168.1.100’,8888)，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中

关键字参数或命名参数

“{server} {1}:{0}”.format(8888, ‘192.168.1.100’, server='Web Server Info : ') ，位置参数
按照序号匹配，
关键字参数按照名词匹配

访问元素

“{0[0]}.{0[1]}”.format((‘magedu’,‘com’))

对象属性访问

from collections import namedtuple
Point = namedtuple(‘Point’,‘x y’)
p = Point(4,5)
“{{{0.x},{0.y}}}”.format§

对齐

'{0}{1}={2:<2}’.format(3,2,23)
'{0}{1}={2:<02}’.format(3,2,23)
'{0}{1}={2:>02}’.format(3,2,23)
‘{:^30}’.format(‘centered’)
‘{:*^30}’.format(‘centered’)

进制

“int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)
“int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}”.format(42)
octets = [192, 168, 0, 1]
‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)

字符串练习

用户输入一个数字

判断是几位数
打印每一位数字及其重复的次数
依次打印每一位数字，顺序个、十、百、千、万…位

#1、判断几位数
x = input('>>>>')
z = x.strip().lstrip('0')
w = len(z)
#长度
print(w)
#输入的是什么
print(z)
2、打印每一位数字及其重复次数
list = [0] * 10
for i in z:
     i = int(i)
     list[i] += 1
     if i == 0:
         continue
     print('数字{}，输入了{}次'.format(i,list[i],end =' '))
3、个位十位打印
print(x[::-1])

输入5个数字，打印每个数字的位数，将这些数字排序打印，要求升序打印

list = []
for x in range(5):
    list.append(int(input('>>>>>').strip().lstrip('0')))
for i in range(5):
    for j in range(4-i):
        if list[j] > list[j+1]:
           list[j],list[j+1]=list[j+1],list[j]
print(list)
w = str(list)
for k in w.strip(' , [],').strip():
    print('输入的数字是：{}，长度是：{}'.format(k,len(k)))