1.什么是字符串（str）

字符串是Python内置的一种容器型数据类型，不可变但是有序；
将单引号或者双引号作为容器，里面可以根据情况放多个字符
不可变：指的是内容的值和顺序不可变
有序:一旦字符串确定，字符串中字符的位置固定

2. 字符串中的内容 - 字符

python中只有字符的概念，没有字符对应的数据类型
字符串的基本单元就是字符，又叫字符串的元素

a.基本字符 - 数字、字母、常用符号、中文等

'asdada '
'12231ada '

b.转义字符 - 通过转移符号 \ 后面跟不同的符号老表示特殊功能和特殊意义的字符

\n 表示换行 ' 表示一个单引号 " 表示一个双引号 \表示一个反斜杠 \t 表示制表符

str1 = "a\'bc\n1\"23\\n000"
print(str1)

阻止转义： 在字符串的最前面加r/R，可以阻止字符串中的转义字符转义
str1 = r"a'bc\n1"23\n000"
print(str1)

c.编码字符 - \u后边跟4位的十六进制数，来表示一个字符。这个4位的16进制数对应的值是字符的编码值

16进制 ： 0-9-a-f

3.字符编码

Python中的字符采用的是Unicode编码
计算机存储数据的时候只能存数字，而且存的是数字的补码（是以二进制的格式进行存储）
100 # 十进制数
print(bin(100)) # bin(数字) - 获取指定数字对应的二进制
print('二进制:', 0b1100100)
print(oct(100), 0o144) # oct(数字) - 获取指定数字对应的八进制
print(hex(100), 0x64) # hex(数字) - 获取指定数字对应的十六进制

编码：每个字符在计算机中存储的时候都会对应一个固定且唯一的数字，这个数字就是这个字符的编码。
每个字符和数字的一一对应关系就是编码表，常见的编码表有：ASCII码表和Unicode编码表。
ASCII码表支队数字字符、字母字符、英文符号进行编码
Unicode编码表是对ASCII表的扩充，能够对世界上所有的符号进行编码

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

ord(字符) - 获取字符对应的编码值，注意：字符值就是长度是1的字符串

print(chr(100))
print(ord('聂'),ord('上'),ord('钦'))
print(chr(32834))
print(chr(0x2C80))

1.获取字符 - 取字符串内容

1.1 获取单个字符

a.语法: 字符串[下标] - 根据下标获取字符串中对应的字符，结果就是获取到的字符
b.说明： 字符串 - 可以是字符串值，也可以是字符串变量，结果是字符串的表达式等都可以
[] - 固定写法
下标 - 又叫索引，一旦字符串确定，那么字符串中每个字符都会对应一个下标，表示这个字符在字符串中的位置。下标的范围是 “0~ 字符串长度减1” 0表示第一个字符，1表示第二个，以此类推。（通用的） 下标范围还可以是 -1 ~ -字符串长度减1, -1表示倒数第一个字符

c.注意： 获取单个字符的时候下标不能越界

str1 = 'py\nthon' # 'p' : 0/-6 'y' : 1/-5
result = 'python'[3]
print(result)
print(str1[0], str1[-6], str1[-1], str1[-2], str1[4])
print(str1[100]) # IndexError: string index out of range
print(str1[-20]) # IndexError: string index out of range

1.2 获取部分字符（字符串切片）

a.语法： 字符串[开始下标:结束下标:步长] - 从开始下标开始，获取到结束下标前为止，每次下标值增加步长；结果是字符串

b.说明： 字符串 - 可以是字符串值，也可以是字符串变量，结果是字符串的表达式等都可以
[],: - 固定写法
开始下标、结束下标 - 下标值，开始下标对应的字符可以取到，结束下标对应的字符一定去不到
步长 - 整数，可以正的也可以是负的

c.注意: 下标可以越界
如果步长为正（从前往后取），开始下标对应的字符要在结束下标对应的字符前才能获取到值
如果步长为负(从后往前取)，开始下标对应的字符要在结束下标对应的字符的后面才能获取到值

str2 = 'abcedf123456'
print(str2[0:4:1])     # 'abce'
print('=', str2[0:4:-1], '=', sep='')      # ''
print(str2[-2:-10:-2])   # '531d'
print(str2[0:100:1])     # 下标可以越界， 'abcedf123456'
print('hello python'[1:-2:3])     # 'eoy'

切片的语法中可以对步长、开始下标和结束下标进行省略:
1.省略步长 (步长默认为1)
字符串[开始下标：结束下标] == 字符串[开始下标：结束下标：1]
2.省略下标
字符串[：结束下标：步长] - 如果步长为正，从字符串开头往后取；如果步长为负，从字符串最后一个字符往前取
字符串[开始下标：：步长] - 如果步长为正，去到最后一个字符为止；如果步长未负，取到第一个字符为止

str2 = 'abcedf123456'
print(str2[2:5])    # 'ced'
print(str2[-4:-1])   # '345'

print(str2[:3:1])    # 'abc'
print(str2[:3:-1])   # '654321fd'

print(str2[2:])     # 'cedf123456'
print(str2[2::-1])  # 'cba'

print(str2[:])     # 'abcedf123456'
print(str2[::-1])  # '654321fdecba'

练习:1234 -> 4321

num = 1234
num_str = str(num)   # 先转换成字符串
new_num_str = num_str[::-1]   # 切片
new_num = int(new_num_str)    # 转换为数字
print(new_num*10)

1.3 遍历字符串 - 一个一个的去除所有的字符

方法一： 直接遍历
for 变量 in 字符串：
循环体

方法二： 通过遍历下标，来遍历字符串
for 变量 in range(字符串长度)：
字符串[变量]

for char in 'hello':
print(char)

str3 = 'when i was young'
len(字符串) - 获取字符串长度,返回一个数字。字符串长度指的是字符串中字符的个数

for index in range(len(str3)):
    print(index, str3[index])

index = 0
while index < len(str3):
    print(index, str3[index])
    index += 1

1.字符串相关运算

a. 数学运算: 字符串支持加法运算和乘法运算
语法 ： 字符串1 + 字符串2 - 将两个字符串拼接在一起产生一个新的字符
new_str = 'abc' + '123'
print(new_str) # abc123

注意：加号两边，必须都是数字，或者都是字符串，数字和字符串不同混合相加！

语法: 字符串 * 正整数 / 正整数 * 字符串 - 指定的字符串重复指定次数，产生一个新的字符串
print('abc' * 3) # abcabcabc
print(''10) # **********

b.比较运算：字符串支持所有的比较运算符
字符串1 == 字符串2, 字符串1 != 字符串2 - 判断两个字符串是否相等
print('abc' == 'abc')
print('abc' == 'acb')
print('abc' != 'acb')

两个字符串比较大小： 让两个字符串中相同位置的字符一一比较(从前往后)，找到第一对不相等的字符，判断编码值大小

print('abcdef' > 'abz')    # False
print('abc' > 'abc')
print('abc1' > 'abc')     # True
print('abc-1' > 'abc')    # True

char = 'a'
应用：
判断一个字符是否是字母：'a' <= char <= 'z' or 'A' <= char <= 'Z'
判断一个字符是否是数字: '0' <= char <= '9'
判断一个字符是否是中文(4e00~9fa5)：'\u4e00' <= char <= '\u9fa5' / 0x4e00 <= ord(char) <= 0x9fa5

print('\u4e00' <= char <= '\u9fa5')
print('一' <= char <= '龥')

练习: 输入一个任意的字符串,统计输入的内容中字母的个数
例如: 输入'abc123你好解释end~~~~' 结果是:6

value = input('请输入一个字符串:')
count = 0
for char in value:
    if 'a' <= char <= 'z' or 'A' <= char <= 'Z':
        # print(char)
        count += 1
print('字母的个数', count)

3. in 和 not in 操作

字符串1 in 字符串2 - 判断字符串1是否在字符串2中(判断字符串2中是否包含字符串1)
字符串1 not in 字符串2 - 判断字符串1是否不在字符串2中(判断字符串2中是否不包含字符串1)

print('abc' in '123abc====')     # True
print('abc' in 'a123bc====')     # False
print('abc' not in 'a123bc====')  # True
print('@' in 'ah@s')        # True

4. 常用内置函数

len(字符串) - 求字符串长度
str(数据) - 将其他数据转换成字符，所有的数据都能转换成字符串, 转换的时候直接在数据的外面加引号
print(int('+23')) # 只有去掉引号后，本身就是一个整数的字符串才能转换成整型
print(float('124.0')) # 只有去掉引号后，本身就是一个数字的字符串才能转换成浮点型
print(bool('')) # 除了空串会转换成False,其他的都会转换成True
str2 = '1'
if str2:
print('不是空串')

1. 字符串的对象方法

字符串.方法()
字符串.capitalize() - 将字符串中首字母大写

str4 = 'hello'
new_str = str4.capitalize()
print(new_str)

字符串.center(width,fillchar) - 产生一个长度为width的新的字符串，新字符串中员字符串居中，剩余的部分用fillchar 填充

new_str = str4.center(11, '0')
print(new_str)   #  000hello000

new_str = str4.center(11, '*')
print(new_str)  # *** hello***

new_str = str4.center(11, ' ')
print(new_str)  #    hello   

字符串.ljust(width, fillchar)

new_str = str4.ljust(11, '=')
print(new_str)

字符串.rjust(width, fillchar)
py1901001\py1901002\py1901010

num = 1    # 001
num = 10   # 010
study_id = str(num).rjust(3, '0')
print(study_id)

字符串.zfill(width) - 产生一个宽度是width的字符串，原字符串在右边，前用0填充

study_id = str(num).zfill(4)
print(study_id)

1.格式字符串 ： 在字符串中通过格式占位符来表示字符串中变化的部分

语法：包含格式占位符的字符 %
说明：

格式占位符： %s   -   字符串
          %d  -    整数
%.Nf  -  浮点数，N可以约束小数都面的小数位数 （N是正整数）
%c  -  字符，数字(数字会自动转换成编码)

name = input('姓名：')
age = int(input('年龄：'))
message = '%s今年%d岁，月薪:%.2f 等级:%c'% (name,age,10000,65)# message = name+'今年'+str(age)+'岁'
print(message)

练习：输入学生姓名，年龄，性别，以'xx今年x岁，性别：x ' 格式打印信息

 name = input('学生姓名：')
 age = int(input('年龄：'))
 gender = input('性别：')
 message = '%s今年%d岁，性别：%c'% (name,age,gender)
 print(message)

2.常用对象方法

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

str1 = 'and you? how are you!'
print(str1.count('you'))

str1 = 'how are you!oh~'
max_count = 0    # 保存一个最大值
max_char = ''    # 保存当前最大次数对应的字符
for char in str1:
    count = str1.count(char)
    if count > max_count:
        max_count = count
        max_char = char
print('%s出现%d次' % (max_char,max_count))

字符串1.find(字符串2) - 在字符串1中查找字符串2 第一次出现的位置，第一次出现的位子，如果找不到就返回 -1 ，找到了就返回第一个字符的下标

字符串1.find（字符串2，开始下标，结束下标） - 字符串1中开始下标到结束下标的范围内查找字符串2第一次出现的位置（不包含结束下标）

print(str1.find('you'))
print(str1.find('you',-8,-1))

在字符串'and you? how are you!oh~'中，找到所有'you'出现的下标。 打印： 4，17,22

str1 = 'and you? how are you!oh~'
str2 = 'you'
start_index = 0
while True:
    index = str1.find(str2,start_index)
    if index == -1:
        break
    else:
        print(index,end=' ')
    # 更新开始下标
    start_index = index + len(str2)

index 的功能和find一样，只是如果字符串2不存在的时候会报错

 print(str1.index('you2'))

字符串1.isdigit() - 判断字符串1中是否只有数字字符

print('21'.isdigit())

字符串1.isnumeric() - 判断字符串是否是数字字符串(可以检查中文数字)
print('千'.isnumeric())

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

print（'*'.join('abc')）
print('++'.join(['ab','b','qwq']))

练习：自己实现join的功能，给字符串1和字符串2，用字符串1的字符把字符串2 中的字符连接起来

 方法一：
str1 = 'qwe'
str2 = '123'
str3 = ''
for char in str1:
    str3 += char + str2
print(str3[:-len(str1)])

方法二：
str3 = ''
for index in range(len(str1)):
    if index == len(str1) - 1:
        str3 += str1[index]
    else:
        str3 += str1[index] + str2
print(str3)

str2 = 'ag23bsh2390s'
str1 = '+'
str3 = ''
for char in str2:
    if '0'<= char <='9':
        str3 += char + str1
print(str3[:-len(str1)])

max(序列)，min(序列) - 求序列中元素的最大值和最小值

print(max('siuabsaonbof'))
print(min('anbsouabcao'))
print(min([100,2,3,-44]))

字符串1.split(字符串2) - 在字符串1把字符串2作为切点，将字符串1切割

print('bgsaaibbdoaboabosaboab'.split('a'))