python03-转义字符、is、字符串(截取、切片、描述判断、切割、大小写替换、空格处理)、find 、count 、random 、replace 、format、print、isinstance

1、转义字符

# print('hahahah\nhahah')
# print('hahahah\thahah')
# print('hahahah\\hahah')
# print('hahahah\'nhahah\'')

 2、查看内存地址

python 中，s1 赋值给s2 ，是赋值给的内存地址。如果内存池中，开辟了一个数值是'hello'的内存，不会在开辟一个新的，而是直接拿来用，s3 在定义，直接拿来用

s1 = 'hello'
s2 = s1
s3 = 'hello'
s4 = 'hello1'
print(s1, s2, s3)
print(id(s1))
print(id(s2))
print(id(s3))
print(id(s4))

3、is 判断内存地址相同不

s1 = 'hello'
s2 = s1
s3 = 'hello'
s4 = 'hello1'
print(s1 is s2)
print(s1 is s3)
print(s1 is s4)

 

4、字符串单点截取取值（正序）

s1 = 'ABCDEFG'
# index[0]=A index[1]=B index[2]=C ....
print(s1[4])

5、字符串单点截取取值（倒序）

s1 = 'ABCDEFG'
# index[-1]=G index[-2]=F index[-3]=E ....
print(s1[-1])
print(s1[-2])

6、获取字符串长度

s1 = 'ABCDEFG'
print(len(s1))

 7、切片（获取从第几位到第几位数据）

注：原则是，从start 开始包括start，到end结束，不包括end

# 切片格式：字符串变量[start:end]
# 不包含end,也就是取start到end-1
s1 = 'ABCDEFG'
# index[0]=A index[1]=B index[2]=C
# index[3]=D index[4]=E....
print(s1[1:4])
print(s1[4])

# 切片可以使用倒叙，格式：字符串变量[start-1:end]
# 比如获取字符串的后二位，格式：字符串变量[-3:-1]
# 不能写成[-1:-3],因为index[-1]=G index[-2]=F index[-3]=E
# 程序中需要正着写
s1 = 'ABCDEFG'
print(s1[-3:-1])

# 需求：字符串很长，只要第2位开始，到最后2位中间的数据
s1 = 'ABCDEFG'
# index[0]=A index[1]=B index[2]=C
# index[-1]=G index[-2]=F
print(s1[1:-2])

# 取倒数第3位到最后
s1 = 'ABCDEFG'
# index[-1]=G index[-2]=F index[-3]=E
print(s1[-3:])

# 从头到尾，跟打印一个字符串是一样输出
# 输出一样，并不代表是一个东西，他们的地址不同
# 说明一个变量池，相同的字符串数值，只能有一个
s1 = 'ABCDEFG'
print(s1[:])
print(s1)
print(id(s1[:]))
print(id(s1))
x = s1[:]
print(s1 is x)

# 跟步长，默认不写是1

# 跟步长，默认不写是1
s1 = 'ABCDEFG'
# 取A开始，到F结束包括F，步长是2，也就是A C E G(G被限制不取)
# 也就是A C E
print(s1[:-1:2])

s1 = 'ABCDEFG'
# 取B开始，到最后，步长是2，也就是B D E F
print(s1[1::2])

步长是正数，如setp=2，ABCDEF --> ACE 。 规则：从start开始从左往右
步长是负数，如setp=-2， 规则：从start开始从右往左

假如，s1 = 'ABCDEF'   print(s1[0:4:-2])   就会得到空值。

s1 = 'ABCDEFG'
print(s1[0:6:-1])  # 是空值

因为start 是0位，也就是A，规则是从右往左走2，A的左侧无任何数据，所以是空

s1 = 'ABCDEFG'
print(s1[3:6:-1]) # 这种也是取不到数值，可能在想起始位置是index(3), -1, 取到index(2)?，并不是，在执行s1[3:6] 将这个字符串拿出来，变成一个新的字符串，在新的字符串中start 就是index(0)

所以，如果start 是4 ，end是0，start 位就是 E，E的左侧是D，可以取到数值

s1 = 'ABCDEFG'
print(s1[6:0:-1])

 如果想遍历所有，可以写成print(s1[::-1])

s1 = 'ABCDEFG'
print(s1[::-1])  # GFEDCBA
print(s1[::-2])  # GECA

8、find 函数

find()  从左到右在给定数值中找到符合()中对应的index位置，find只回执满足的第一个，未找到反回 -1

index()  从左到右在给定数值中找到符合()中对应的index位置，index只回执满足的第一个，未找到报错

获取等号后面的blog

url = 'https://blog.csdn.net/Jerry00713?type=blog'
i = url.find('=')  # =是整个url唯一一个，find找到index
print(i)
last = url[i+1:]   
print(last)

find()  和 index()  

url = 'https://A.B.C.D'
i = url.index('.')
b = url.find('.')
print(i)
print(b)
last = url[i+1:]
print(last)

rfind()  从右到左在给定数值中找到符合()中对应的index位置，rfind只回执满足的第一个，未找到反回 -1

rindex()  从右到左在给定数值中找到符合()中对应的index位置，rindex只回执满足的第一个，未找到报错

获取 net/Jerry00713?type=blog'

url = 'https://blog.csdn.net/Jerry00713?type=blog'
i = url.rfind('.')
print(i)
last = url[i+1:]
print(last)

如果找的是一个字符串，则返回字符串的第一个数值的index

url = 'bc.abc#abc.abcd'
i = url.find("abc")
print(i)    # 返回符合要求的第一个abc的a的index,也就是3

9、count 函数

count () 计算出出现的次数

url = 'https://blog.csdn.net/Jerry00713?type=blog'
i = url.count(".")
print(i)

10、random 函数

random 函数是一个随机数函数

random.randint ()  随机整数，按照 ( ) 中的规则判断

import random

a = random.randint(1, 9)
print(a)

 使用 random.randint ()  中的字符串，随机4位的数字

import random

filename=''
s = 'abcdefABCDEF123456'
for i in range(4):
    index = random.randint(0, len(s)-1)
    filename += s[index]
print(filename)

11、字符串描述判断(以下函数只能调用字符串)

capitalize  首字母大写
istitle        是不是每个单词首字母大写
startswith 是否以什么开头
endswith  是否以什么结尾
isalpha   是否是纯字母（字母包括汉字）
isdigit     是否是纯数字
isalnum  是否是数字或者字母（字母包括汉字）
isspace  是否是一个空白字符串(必须>=1 空格)
isupper  判断是否全部是大写字母组成
islower  判断是否全部是大写字母组成

返回数值都是bool类型

判断是不是以https开头的

url = 'https://blog.csdn.net/Jerry00713/article/details/126737304'
result = url.startswith('http:')   # False
result1 = url.startswith('https:')  # True
print(result, result1)

判断上传的是不是图片，图片名字长度不能大于6位，如果大于6位，自动修改

filename = ''
s = 'abcdefABCDEF123456'
file = input("输入文件全名称,并且图片名字长度不能大于6位：")
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    a = file.rfind('.')
    c = file[:a]
    if len(c) > 6:
        for i in range(6):
            index = random.randint(0, len(s) - 1)
            filename += s[index]
            file = filename + file[a:]
        print("已修改文件名字叫%s" % file)
    else:
        b = file[a + 1:]
        print("格式类型是:%s" % b)
        print("文件名字是:%s" % c)
else:
    print("格式不正确")

isdigit   是否是纯数字    isalpha   是否是纯字母

s = '123'
b = 'abc'
c = '你好'
d = '#123csz'
print(s.isdigit())  # True
print(b.isdigit())  # False
print(c.isdigit())  # False
print(d.isdigit())  # False

print(s.isalpha())  # False
print(b.isalpha())  # True
print(c.isalpha())  # True
print(d.isalpha())  # False

isalnum  是否是数字或者字母（字母包括汉字）

s = '123'
b = 'abc'
c = '123scf'
d = '你好'
f = '#123csz'
print(s.isalnum())  # True
print(b.isalnum())  # True
print(c.isalnum())  # True
print(d.isalnum())  # True
print(f.isalnum())  # False

istitle        是不是每个单词首字母大写

print('My Name Is'.istitle())   # True 
print('My name Is'.istitle())   # False

isspace  是否是一个空白字符串(>=1个空格) 

s = ''
b = ' '
c = ' asd'
print(s.isspace())  # False
print(b.isspace())  # True
print(c.isspace())  # False

项目需求：

# 使用手机号/用户名作为账号 + 密码登录
# 用户名：全部小写，首字母不能是数字，长度必须6位以上
# 手机号：纯数字  长度11
# 密码：必须6位数字
# 符合以上要求进行下层验证，密码次数超过3次，失败
# 判断用户名+密码正确，返回成功，不正确返回失败

flag = True   #
while flag:   # 定义flag=True,当程序中出现flag = False，就会将while 变成 False，进而退出循环
    name = input("输入用户名/手机号码:")
    i = 1
    if (name.islower() and name[0].isalpha() and len(name) >= 6) or (len(name) == 11 and name.isdigit()):
        while True:
            password = input("请输入密码")
            if len(password) == 6 and password.isdigit():
                if (name == '12345678912' and password == '123456' or name == 'admin123' and password == '123456'):
                    print("验证成功")
                    flag = False   # 下方break会跳出当前的while True，由于flag = False，跳出while flag
                else:
                    print("验证失败")
                break
            elif i == 3:
                print("密码次数超过3次，失败")
                break
            else:
                print("密码必须6位数字")
                i += 1
    else:
        print("账户名错误")

12、replace 函数

replace 替换

格式：replace( '内容' , '替换内容' )  默认替换所有匹配字符

s = '你好，世界,真大啊，世界你好'
result = s.replace('世界', 'world')
print(result)  # 你好，world,真大啊，world你好

 格式：replace( '内容' , '替换内容', count )  只替换符合的要求前count 个

s = '你好，世界,真大啊，世界你好,你好世界'
result = s.replace('世界', 'world',2)
print(result)   # 你好，world,真大啊，world你好,你好世界

13、切割字符串

split 左切割，可以按照指定的字符进行切割，从左到右，切割后成为一个列表
rsplit 右切割，可以按照指定的字符进行切割，从右到左，切割后成为一个列表
splitlines 按照行切割
partition  左切割，从左到右，可以按照指定的字符进行切割成三部分，切割后成为一个列表，第一部分是，符合切割符要求的第一个，列表第二位显示是什么分隔符，列表第三位显示是剩余数据不进行分割，直接放入
rpartition  右切割，从右到左，可以按照指定的字符进行切割成三部分，切割后成为一个列表，第一部分是，符合切割符要求的第一个，列表第二位显示是什么分隔符，列表第三位显示是剩余数据不进行分割，直接放入

格式split ('分隔符') 

s = '你好,世界 世界,真大 全面世界,人民'
result = s.split(' ')
print(result)

s = '你好,世界 世界,真大 全面世界,人民'
result = s.split(',')
print(result)

格式split ('分隔符',maxsplit)   代表最大切割次数

s = '你好,世界世界,真大全面世界,人民'
result = s.split(',', 2)
print(result)

格式splitlines()   按照行切割 ，其中()中无任何意义

s = '''你好
世界世界,真大全面世界
人民
'''
result = s.splitlines()
print(result)

 格式partition ()   按照行切割 ，其中()中无任何意义

s = '你好 世界 世界 真大 人民'
result = s.partition(' ')
result1 = s.rpartition(' ')
print(result)
print(result1)

14、字符串大小写替换

upper 将字符串中小写的字母转成大写，如果存在其他字符，则原封不动输出

s = 'abcABC'
s1 = '123你好abcABC'
result = s.upper()
result1 = s1.upper()
print(result)
print(result1)

lower 将字符串中大写的字母转成小写，如果存在其他字符，则原封不动输出

s = 'abcABC'
s1 = '123你好abcABC'
result = s.lower()
result1 = s1.lower()
print(result)
print(result1)

.title() 将首字母大写

list ='hello'
print(list.title())

.swapcase()   大写转小写、小写转大写转

print('Nihao Shijie'.swapcase())
print('nIHAO sHIJIE'.swapcase())
print('nI世界#123'.swapcase())

15、空格处理

ljust  左对齐
rjust  右对齐
center  按要求居中对齐
lstrip  移除左端的空格，中间、尾数据不动
rstrip 移除右端的空格，中间、尾数据不动
strip  移除头尾两端的空格，中间数据不动

问题：input 输入空格后，len算其长度么，答案是算，一个空格一个字符。
如何对避免，用户名不允许使用空格。

strip  移除头尾两端的空格，中间数据不动

s = '  admin user      '
a = s.strip()
print(a)
print(len(a))

rstrip 移除左端的空格，中间、尾数据不动

s = '  admin user      '
a = s.lstrip()
print(a)
print(len(a))

center  按要求居中对齐

center(偶数)：s字符串本身10个字符，使用center(14)，14-10=4  4÷2=2，给最前端跟最后端各添加2个字符，默认添加空格字符

center(奇数)：如果是奇数，怎么给前端跟、后端平均分配？先可前端分配。默认添加空格字符

如何修改默认字符   (s.center(30, '#'))

ljust  左对齐、rjust  右对齐

s字符串本身10个字符，使用ljust (14)，14-10=4  给最后端各添加4个字符

 

16、format 函数

format 函数，引入变量

 格式：'字符串{},字符串{}'.format(变量1, 变量2) 

name = '刘'
age = 18

result = '你好{},你今年{},请这边走'.format(name, age)  # {} 引入后面的变量
print(result)

format 变量复用 

format 关键字参数

如下，format传递变量报错

所以需要变量名

format_map 后面接字典

dict = {'name': '刘', 'age': 18}
name = '刘'
age = 18

result = '你好{},你今年{},请这边走'.format(name, age)  # {} 引入后面的变量
print(result)
result1 = '你好{name},你今年{age},请这边走'.format_map(dict)
print(result1) 

17、print

最后以为什么字母结尾

print(s.center(30), end='#')

print (sep=' ')  意思是在元素之间用什么拼接

print('nihao','世界',sep='--')

18、isinstance

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。