一、字符串和字符

1.什么是字符串(str)

字符串是容器型数据类型，将''/""/''''''/""""""作为容器的标志，容器中的元素全是字符
不可变的（不支持增删改）、有序（支持下标操作）

str1 = 'hello'
str2 = "hello"
str3 = '''hello'''
str4 = """hello"""
print(type(str1))
print(type(str2))
print(type(str3))
print(type(str4))

2.字符串中的元素 - 字符

python中只有字符的概念，没有对应的数据类型。引号中只有一个元素的字符串可以看出一个字符
字符串又叫字符集

1）字符串中的字符 - 原则上任何可以通过键盘输入或者从其他地方赋值粘贴的所有符号都可以作为字符

a.普通字符：在字符串中能够代表符号本身的字符（没有特殊意义和特殊功能的符号）

b.转义字符：在字符串中有特殊意义和特殊功能的符号的组合，一般是以 \ 开头的

\n - 换行
' - 表示'本身
" - 表示"本身
\t - 表示一个缩进(tab键)
\ - 表示一个
注意：所有的转义字符的长度都是1

c.编码字符

2）阻止转义：在字符串的最前面加r/R可以让当前字符串中所有转义字符失效（所有符号都表示这个符号本身）

\u四位的16进制数 - 编码字符（获取4位16进制数作为编码值对应的字符）

str1 = 'abc\n123'
print(str1)

str2 = 'abc\'123'
print(str2)

str3 = '\tabc'
print(str3)

str4 = 'abc\\n123'
print(str4)

str5 = 'abc\u28dd'
print(str5)

str6 = r'\tabc\n\'123'
print(str6)

3.字符编码

计算机不能直接存储字符（符号），只能存储数字；
为了能够存储字符，把每一个字符关联了一个固定的数字（这个固定的数字就是字符的编码）

字符和数字一一对应关系就是编码表：ASCII码表，Unicode编码表（python）

1）ASCII码表 - 在计算机中采用一个字节保持一个字符（总共128个字符），字符包含了所有的字母、数字、和美国常用符号

0：48
A：65
a：97

2）Unicode编码表

Unicode编码表是ASCII码表的扩展，包含了世界上所有的国家、所有的语言对应的符号（总共有65536个符号）
中文编码值范围：
0x4e00 — 0x9fa5

1.编码字符：\u4位的16进制编码值

str1 = 'abc\u6fff'
print(str1)

2.chr(编码值) - 获取编码值对应的字符

 print(chr(97))
 num = 0
 for x in range(0x0f00, 0x0fff+1):
     print(chr(x), end=' ')
     num += 1
     if num % 30 == 0:
         print()

3.ord(字符) - 获取指定字符对应的编码值

print(hex(ord('小')), hex(ord('明')))

二、字符串操作

1.查 - 获取字符（和列表获取元素的方式一样）

1)获取单个字符:字符串[下标]

2)切片：字符串[开始下标：结束下标：步长]

3)遍历：直接遍历元素、通过下标遍历

注意：一个空格是一个字符；按tab键是4个空格，4个字符；\t对应一个字符

获取单个字符

str1 = '\thello Python!'
print(str1[-2])   # n
print(str1[2])    # e

切片

print(str1[2:])   # ello Python!
print(str1[1:-1:2])   # hloPto
print(str1[:3:-1])    # !nohtyP ol

遍历

for x in str1:
    print('x:', x)

for 下标，元素 in enumerate(序列):

循环体

for index, item in enumerate(str1):
    print(index, item)

2.相关操作

1）运算符：

a. +、*

str1 = 'abc'
str2 = '123'
print(str1 + str2)
print(str1 * 3)

b. ==, !=, is

print('abc' == 'abc')  # True
print('abc' == 'acb')  # False

>, <, >=, <=

字符串1 > 字符串2

字符串比较大小比较的是字符串编码值的大小

判断字符是否是小写字母：'a' <= char <= 'z'
判断字符是否是大写字母：'A' <= char <= 'Z'
判断字符是否是字母：'a' <= char <= 'z' or 'A' <= char <= 'Z'
判断字符是否是中文：'\u4e00' <= char <= '\u9fa5'
判断字母是否是数字：'0' <= char <= '9'

print('abcdef' > 'bc')  # False
print('Z' < 'a')  # True

char = '中文'
if '\u4e00' <= char <= '\u9fa5':
    print('是中文')
else:
    print('不是')

练习：输入一个字符串，判断这个字符串是否是中文字符串(全是中文)

 i = input('输入:')
 for x in i:
     if not '\u4e00' <= x <= '\u9fa5':
         print('不是')
         break
 else:
     print('是')

in/not in

字符串1 in 字符串2 -> 判断字符串2中是否包含字符串1

st3 = 'abc 123'
st4 = 'b'
print(st4 in st3)    # True
print('abc' in st3)    # True
print('ac' in st3)    # False

3)相关函数：len、str、sorted、reversed

a.len(字符串) 转义字符长度是1

print(len('\tabc\n123'))

b.str(数据) - 所有的数据都能转换成字符串；直接将原数据的打印值加引号

a = 100
str(a)      # '100'
list1 = [10, 20, 30]
str(list1)    # '[10, 20, 30]'

c.sorted(字符串)

str5 = 'python12Q'
print(sorted(str5))     # ['1', '2', 'Q', 'h', 'n', 'o', 'p', 't', 'y']
list2 = sorted(str5)
print(''.join(list2))    # 12Qhnopty

三、格式字符串

1.格式占位符

a.语法：包含格式占位符的字符串 % （值1，值2，值3，..........）

b.说明：

格式占位符 - 格式占位符有哪些是固定的，使用的时候和字符串中变化的数据类型相关

    %s    -  字符串（任何类型都可以使用%s占位）
    %d    -  整数；
    %-Nd  -  整数：N约束数字最后的长度，如果不够后面补空格
    %Nd   -  整数；N约束数字最后的长度，如果不够前面补空格
    %f    -  浮点数；小数点后面保留6位小数
    %.Nf  -  浮点数，N约束小数点N后的小数位数
    %c    -  字符、字符对应的编码值

% - 固定写法
() - 固定写法；如果值的个数是1可以省略
值 - 任何有结果的表达式；值的个数和类型和前面占位符的个数及类型保持一致

 name = input('请输入姓名：')
 age = int(input('请输入年龄：'))
 print('你好，我是%s,今年%d岁,工资:%.2f, %s' % (name, age, 1000, 1.234))

2.format

一个带有{}的字符串.format(值1，值2，值3，......)

用法1:让空的{}个数和format中值的个数保持

print('我是{},今年{}岁'.format('二电厂', 18))

用法2:{N} N从0开始依次增加，分别表示format中第0个值，第1个值，......

print('我是{0},今年{1}，年是{1}'.format('展现出', 18))
print('数据1：{1}，数据2：{0}，数据3：{1}'.format(10, 20))

用法3：[key]

'{key1}， {key2}'.format(key1=值1，key2=值2)

print('我是{name}，年龄{age}，今年{age}'.format(name='阿萨德', age=18))

用法4：用列表元素给占位符赋值

list1 = [10, 20, 30, 40]
print('{0[0]},{0[1]},{0[3]}'.format(list1))
print('{1[1]},{0},{1[2]}'.format('张三', list1))

用法5：用字典的值给占位符赋值（了解）

student = {'name': '小明', 'age': 20, 'id': '001', 'score': 100}
print('{name}今年{age}岁，学号是{id}，考了{score}'.format(**student))
# format(**student)  -->  format(name='小明', age=20, id='001', score=100)

其他的写法：

print('圆周率{:.2f}'.format(3.1415926))  # 约束小数位数
# 约束整数宽度
print('整数：{:x>3d}.'.format(25))  # x25
print('整数：{:a<3d}.'.format(25))  # 25a
# 分割
print('{:,}'.format(10000000000000))  # 10,000,000,000,000
# 百分比
print('{:.2%}'.format(0.25))

四、字符串相关方法

1.字符串.capitalize() - 将字符串的首字母变成大写字母

str1 = 'python'
print(str1.capitalize())

center/ljust/rjust/zfill

字符串.center(宽度，填充字符) - xabcx
字符串.ljust(宽度，填充字符) - abcxx
字符串.rjust(宽度，填充字符) - xxabc
字符串.zfill(宽度) == 字符串.rjust(宽度, '0')

print('abc'.center(7, 'x'))
print('abc'.ljust(7, 'x'))
print('abc'.rjust(7, 'x'))
print('abc'.zfill(7))
num = 2
print(str(num).zfill(3))

字符串1.count(字符串2) -> 统计字符串1中字符串2出现的次数

字符串1.count(字符串2，开始下标，结束下标) -> 统计字符串1开始下标到结束下标范围类字符串2出现的次数

str2 = 'how are you? i am fine! fuck you!'
print(str2.count('you'))
print(str2.count('a'))

print(str2.count('you', 0, 15))

str1 = 'abc'
str2 = 'how are you'

判断str2是否以str1结尾

print(str2[-len(str1):])

字符串查找

字符串1.find(字符串2) - 获取字符串2第一次在字符串1出现的位置（用大于等于0的下标值表示）；
字符串2不存在的结果是-1
字符串1.index(字符串2) - 获取字符串2第一次在字符串1出现的位置（用大于等于0的下标值表示）；
字符串2不存在会报错

str2 = 'how are you? i am fine! fuck you!'
print(str2.index('you'))
print(str2.find('you'))

join

字符串.join(序列) - 将序列中的元素用字符串连接在一起产生一个新的字符串；
序列中的元素是字符串

str3 = '+'.join('abc')
print(str3)  # a+b+c

str4 = ' '.join(['name', 'age', 'gender'])
print(str4)

str5 = ''.join({'a': 1, 'b': 2})
print(str5)

字符串替换

1)字符串1.replace（字符串2，字符串3） -> 将字符串1中所有的字符串2都替换成字符串3

2)字符串1.maketrans(字符串2，字符串3) -> 创建字符串2和字符串3一一对应的映射表

字符串1.translate(替换的映射表)

str2 = 'how are you? i am fine! thank you!'
new_str2 = str2.replace('you', 'me')
print(new_str2)   # how are me? i am fine! thank me!

创建映射表

table = str.maketrans('a!', 'b+')
new_str2 = str2.translate(table)  # 将str2中所有a都替换成b，所有的！都替换成+
print(new_str2)

字符串切割

字符串1.split(字符串2) - 将字符串1中所有的字符串2作为切割点切成多分

str2 = 'how are you? i am fine! fuck you!'
print(str2.split(' '))