day.8 字符串

字符串

什么是字符串(str)

字符串是容器型数据类型(序列)，将’‘或者""或者’’’’’’'或者"""""""作为容器标准，里面每一个独立的符号就是字符串的一个元素
字符串不可变；字符串是有序的(支持下标操作)
字符串的元素：引号里面的每个符号都是字符串的元素，字符串的元素又叫字符，字符分为两种: 普通字符，转义字符

​ 1.空串 (引号中什么都没有，空格也不行)

empty1 = ''
empty2 = ""
empty3 = ''''''
empty4 = """"""
print(type(empty1), len(empty1))  # <class 'str'> 0
print(type(empty2), len(empty2))  # <class 'str'> 0
print(type(empty3), len(empty3))  # <class 'str'> 0
print(type(empty4), len(empty4))  # <class 'str'> 0

​ 2. 字符串的容器标志

'' 和 "" 没有区别； '''''' 和 """""" 没有区别
'' 和 "" 里面的内容不能通过直接按回车换行，只能通过转义字符
'''''' 和 """"""  里面的可以通过回车换行

str11 = 'abc'

str1 = '窗前明月光，\n疑似地上霜'  # 加\n  单引号换行
str2 = """床前明月光，
疑似地上霜"""

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

"""
字符分为普通字符和转义字符
1)普通字符  -  在字符串中表示符号本身的字符
2)转义字符  -  使用\和其他符号一起来表示特殊功能和意义的字符
\n  -  换行
\t  -  水平制表符(相当于tab键)
\'  -  表示一个普通的单引号
\"  -  表示一个普通的双引号
\\  -  表示一个普通的反斜杠
3) 阻止转义  -  让字符串中所有的转义字符功能消失(让一个字符串中的每一个字符都是表示符号)
在字符串前加r/R；  r" , R"

4) 转义字符  -  编码字符
"""

补充：

# \u4位的16进制数  -  16进制数的编码值对应的字符

str1 = '\tabc\n123'
print(str1)

str2 = 'I\' s me'
print(str2)

str3 = "it's me"
print(str3)

str4 = 'is "A"'
print(str4)

str6 = 'c:users\\name\\next.txt'
print(str6)

str7 = r'c:users\name\next.txt'
print(str7)

str8 = r'\'taz\n321\asd\\98'

str9 = 'abc\u4e60123'
print(str9)   # abc习123

3. 编码值 - 字符编码

计算机只能用二进制保存数字

1.编码值 - 计算机在存储符号的时候其实存的是这个符号对应的固定数字，这个数字就是对应的编码值

2.编码表 - 字符和数字一一对应的表

'''
ASCII码表  - 总共有128个符号，只有美国常用符号，不包括中文
***！！！ 数字在字母的前面，大写字母在小写字母前面，(A-65,a-97),大写字母和小写字母之间有间隙 （记！）

Unicode编码表(python)  -  Unicode编码表包含ASCII码表
                        包含了目前世界上所有民族的所有语言符号(万国码)
                        中文编码范围：4e00 ~ 9fa5
                        
chr(编码值)  -  获取编码值对应的字符
ord(字符)   -   把字符转换成对应的数字
编码字符  -  \u4e00
'''
print(chr(97))  # 'a'
print(chr(0x4e01))  # '丁'

print('\u0061123')  # a123

计算机基础

1. 内存单位
   位(bit) - 计算机内存最小单位
   字节(byte) = 一字节等于8位(bit) - 程序申请内存的最小单位
   1kb = 1024 字节
   1MB = 1024 kb
   1G = 1024 MB
   1T = 1024 G

2. 进制

计算机中数字常见进制有4中：2进制、8进制、10进制、16进制

​ 1. 10进制

"""
基数：  0、1、2、3、4、5、6、7、8、9
进位：  逢10进1
位权：  10**(N-1)  123 = 1*100 + 2 * 10 + 3*1
表达方式： 直接写
"""

print(110)  # 110

​ 1. 2进制

"""
基数： 0、1
进位： 逢2进1
位权： 2**(N-1)  110 = 0*2**0 + 1*2**1 + 1*2**2 = 6
表达方式: 加前缀0b、0B     # print(0b1100)  # 12
"""

print(0b1100)  # 12
# print(0b12)  # 错误

​ 2. 8进制

"""
基数： 0、1
进位： 逢8进1
位权： 8**(N-1)
表达方式： 加前缀0o  # print(0o26)  # 22 == 6*8**2 + 2*8**1 = 6 + 16
"""

print(0o26)  # 22 == 6*8**2 + 2*8**1 = 6 + 16

​ 3. 16进制

"""
基数： 0、1、2、3、4、5、6、7、8、9、a/A、b、c、d、e、f
进位： 逢16进1
位权： 16 ** (N-1) 1f = f*16**0 + 1*16**1 = f + 16 = 15 + 16 = 31
表达方式： 加前缀0x、0X  # print(0x1f)  # 31
"""

print(0x1f)  # 31

# hex  -  将其他进制的数据转换成16进制数据
print(bin(123))

字符串的相关操作

1. 查 - 字符串获取字符和列表获取元素的语法一样

message = 'you see see one day day!'
print(message[2], message[-1])  # u  !

# 一个空格是一个字符
str1 = 'abc 123'
print(str1[4]) 

# 一个转义字符是一个字符，长度是1
str2 = '\tabc\9u4fa 123'
print(str2[6])

message = 'you see see one day day!'
print(message[1:5])  # ou s
print(message[:-5:-1])  # !yad

for x in 'ab\u67afc':
    print(x)  # a , b , （\u67af）枯 ，c

2. 运算符

# 字符串1 + 字符串2  -  将两个字符串拼接产生一个新字符串
print('abc' + '123')  # abc123
# 字符串 * N  -  将字符串重复N次 产生一个新的字符串
print('abc' * 3)  # abcabcabc

print('abc' == 'acb') # False
print('a' == '\u0061')  # True  \u0061 == a

# 比较大小：>、 < >= <=
# 两个字符串比较大小比较的是第一对不相等的字符的编码值的大小
"""
是否是数字字符： '0' <= char <='9'
是否是小写字母： 'a' <= char <= 'z'
是否是大写字符： 'A' <= char <= 'Z'
是否是字母： 'a' < = char <= 'z' or 'A' <= char <= 'Z'
是否是中文：'\u4e00' <= char <= '\u9fa5'
"""

print('abc' > 'cd')  # False  

# 练习：提取一个字符串中所有的数字字符
 ''sh函数78sk--2o'  -> '782'' -> '782'
 x = 'sh函数78sk--2o'
 y = ''
 for z in x:
     if '\u4e00' <= z <= '\u9fa5':
         y += z
 print(y)

x = 'sh函数78sk--好2o'
f = ''
for z in x:
    if '\u4e00' <= z <= '\u9fa5':
        f += z
print(f)

3. in 和 not in

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

print('abc' in 'a1b2c3')  # False
print('abc' in 'abc123')  # True  必须是一部分，不是存在里面
print('1' in 'abc123')    # True 

4. len、str

# str(数据)  -  将数据转换成字符串。(任何类型的数据可以转换成字符串，转换的时候是在数据的打印值外加引号)
print(str(100))  # '100'
print(str(12.5)) # '12.5'

list1 = [1, 2, 3]
print(str(list1))  # '[1, 2, 3]'

dict1 = {'name': '小明', 'age':'18'}
print(str(dict1))  # "{'name': '小明', 'age': '18'}"

dict2 = {"name": '小明'}
print(str(dict2))

func1 = lambda x: x*2
print(func1)   # ‘<function <lambda> at 0x0000018C7B3D7A60>'

字符串的相关方法

1. join

# 字符串.join(序列)  -  将系列中元素使用是定字符串链接产生一个新的字符串。序列中的元素必须是字符串
naems = ['小明', '奶娃', '坚果']
result = ''.join(naems)
print(result)   # 小明奶娃坚果

result = '='.join(names)
print(result)  # 小明=奶娃=坚果

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

num =[10, 9, 78, 67]
result = ','.join(([str(x)for x in num]))
print(result)  # 10,9,78,67

list1 = ['name', 20, True, '你好', '哈哈']
x ='+',join([x for x in list1 if type(x) == str])
print(x) # name+你好+哈哈

2. split

# 字符串1.split(字符串2）  -  将字符串1中所有的字符串2作为切割点对字符串1进行切割
# 字符串1.split(字符串2 N） -  将字符串1中前N个字符串2作为切割点进行切割
str1 = 'how are you? i am fine, thank you! and you?'
result = str1.split(' ')
print(result)  # ['how', 'are', 'you?', 'i', 'am', 'fine,', 'thank', 'you!', 'and', 'you?']  空格作为切割点

sesylt = str1.split('you')
print(result)  # ['how are ', '? i am fine, thank ', '! and ', '?']

print('abca123amn'.spult('a'))  # ['', 'bc', '123', 'mn']

str1 = 'abc12mn12xy12==12++'
print(sr1.split('12', 2))  # ['abc', 'mn', 'xy12==12++']  2控制切割次数 切割2次

3. repalce

# 字符串1.replase(字符串2,字符串3) -  将字符串1中所有的字符串2都替换成字符串3
str1 = 'how are you? i am fine, thank you! and you?'
result = str1.repalce('you', 'me')  把str1中的you变成me
print(result)  # how are me? i am fine, thank me! and me?

result = str1.repalce('you', 'me', 1)  1是只替换一次
print(result) # # how are me? i am fine, thank you! and you?

作业

1输入一个字符串，打印所有奇数位上的字符(下标是1，3，5，7…位上的字符)

# 例如: 输入**'abcd1234 ' **  输出**'bd24'**
x = 'abcd1234'
print(x[1::2])

2.输入用户名，判断用户名是否合法(用户名长度6~10位)

x = input('请输入用户名： ')
if 6 <= len(x) <= 10:
    print('用户名合法')
else:
    print('用户名不合法')

3.输入用户名，判断用户名是否合法(用户名中只能由数字和字母组成)

x = input('请输入用户名:')
if '0' <= x <= '9' or 'a' <= x <= 'z' or 'A' <= x <= 'Z':
    print('用户名合法')
else:
    print('用户名不可法')

4.输入用户名，判断用户名是否合法(用户名必须包含且只能包含数字和字母，并且第一个字符必须是大写字母)

# 例如: **'abc'**  — 不合法    **'123'**  — 不合法   **'abc123'**  — 不合法    **'Abc123ahs'**  — 合法
str1 = input('请输入用户名：')
hasnum = False
if 'A' <= str1[0] <= 'Z':
    for x in str1[1:]:
        if '0' <= x <= '9':
            hasnum = True
        elif 'a' <= x <= 'z':
            pass
        elif 'A' <= x <= 'Z':
            pass
        else:
            print('不合法')
            break
    else:
        if hasnum:
            print('合法')
        else:
            print('不合法')
else:
    print('用户名不可法')

5.输入一个字符串，将字符串中所有的数字字符取出来产生一个新的字符串

x = 'abc1shj23kls99+2kkk'
f = ''
for z in x:
    if '0' <= z <= '9':
        f += z
print(f)

6.输入一个字符串，将字符串中所有的小写字母变成对应的大写字母输出 (用upper方法和自己写算法两种方式实现)

ste1 = 'a2h2klm12+'
ste2 = ''
for x in ste1:
    if 'a' <= x <= 'z':
        x = chr(ord(x) - 32)
    ste2 += x
print(ste2)

"""
ste1 = 'a2h2klm12+'
ste2 = ''
for a in st1  
x = a  
if 'a' <= 'a' <= 'z' -> if True 
x = chr(ord(a) - 32  ->  x = chr(97 - 32) -> x = chr(65)  x = A
ste2 = '' + 'A'  ->  ste2 = 'A'

x = 2
if 'a' <= 2 <= 'z' if False
ste2 = 'A' + '2' -> ste2 = 'A2'

"""

7.输入一个小于1000的数字，产生对应的学号

x = input('请输入数字：')
if len(x) == 1:
    print('py190100', x, sep='')
elif len(x) == 2:
    print('py19010', x, sep='')
elif len(x) == 3:
    print('py1901', x, sep='')

8.输入一个字符串，统计字符串中非数字字母的字符的个数

ste1 = input('请输入')
ste2 = 0
for x in ste1:
    if '0' <= x <= '9' or 'a' <= x <= 'z' or 'A' <= x <= 'Z':
        ste2 += 1
print('个数是：', len(ste1) - ste2)

9.输入字符串，将字符串的开头和结尾变成’+’，产生一个新的字符串

10. 输入字符串，获取字符串的中间字符

11.写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)

str1 = 'how are you? Im fine, Thank you!'
str2 = 'you'
print(str1.find(str2))

12.获取两个字符串中公共的字符

str1 = 'abc123'
str2 = 'aen2'
str3 = ''.join([x for x in str1 if x in str2])
print(str3)