1.前言

隔离日记DAY6

2.学习内容

1.字符串的劈分

?s='hello world python'
?lst=s.split()#从字符串的左侧开始劈分，默认劈分符是空格字符串，返回值都是列表
?print(lst)#['hello', 'world', 'python']
?s1='hello|world|python'
?print(s1.split(sep='|'))#sep用来指定劈分符 ['hello', 'world', 'python']
?print(s1.split(sep='|',maxsplit=1))#通过参数maxsplit指定最大劈分次数，经过最大劈分次数后，剩余的字符串会单独作为一部分
?print('------------------------------')
?'''rsplit()从右侧开始劈分'''
?print(s.rsplit())
?print(s1.split('|'))
?print(s1.rsplit(sep='|',maxsplit=1))#二者区别在这里['hello|world', 'python']

这一部分没什么可赘述的，看程序一目了然

2.字符串判断的相关方法

?s='hello,python'#字母 数字 下划线才是合法的标识符
?print('1.',s.isidentifier())#False s中含有逗号，所以不是. ?  isidentifier()判断指定字符串是不是合法标识符
?print('2.','hello'.isidentifier())#2. True
?print('3.','张三_'.isidentifier())#3. True，为啥汉字也合法，因为汉字也由字母组成
??
?print('5.','\t'.isspace())#5. True  isspace判断字符串是不是全部由空白字符组成（回车，换行，水平制表符）
??
?print('6.','adc'.isalpha())#6. True  isalpha判断字符串是否全由字母组成
?print('7.','张三'.isalpha())#7. True
?print('8.','张三1'.isalpha())#8. False
??
?print('9.','123'.isdecimal())#9. True  isdecimal判断是否全由十进制数组成，（罗马数字不是十进制数）
?print('10.','123四'.isdecimal())#false
??
??
?print('11','123'.isnumeric())#True ?  isnumeric判断是否全由数字组成 （罗马数字也行）
?print('12','123四'.isnumeric())#True
??
?print('13','abc1'.isalnum())#True ?  isalnum判断是否全由字母和数字组成
?print('14','张三123'.isalnum())#True ?  张三也是字母
?print('15','abc!'.isalnum())#15 False  !不行

注意汉字也是合法标识符，因为其由字母组成

3.字符串的替换与合并

?s='hello,python'
?print(s.replace('python','java'))#替换
?s1='hello,python,python,python'
?print(s1.replace('python','java',2))#hello,java,java,python第三个参数为替换次数
??
??
?lst=['hello','java','python']
?print('|'.join(lst))  #hello|java|python 连接
?print(''.join(lst)) ? #hellojavapython
??
?t=('hello','java','python')
?print(''.join(t))#hellojavapython
??
?print('*'.join('python'))#p*y*t*h*o*n

print(s.replace('python','java'))#替换就是把字符串中的python换成java，这一部分也比较好理解。

4.字符串的比较操作

?print('apple'>'app')#True
?print('apple'>'banana')#False  a与b原始值（ASCII码）比较  相当于97 >98 False
?print(ord('a'),ord('b'))
??
?print(chr(97),chr(98))#a b ? ? chr与ord互为对应
??
?'''==与is的区别
? ? == 比较的是值value
? ? is 比较的是id是否相等'''
?a=b='python'
?c='python'
?print(a==b)#True
?print(b==c)#True
??
?print(a is b)#true
?print(a is c)#true
?print(id(a))#a b c内存地址全相同 字符串驻留机制：当发现有相同字符串时，不会再创建新的字符串，而指向相同字符串的空间
?print(id(b))#同
?print(id(c))#同

比较字符串时是比较其ASCII码的大小，且逐次从左到右比较
chr与ord互为对应
==与is的区别 == 比较的是值value is 比较的是id是否相等
a b c内存地址全相同字符串驻留机制：当发现有相同字符串时，不会再创建新的字符串，而指向相同字符串的空间

4.字符串的切片操作

?s='hello,python'
?s1=s[:5]#hello 由于没有指定起始位置，所以从0开始切
?s2=s[6:]#python由于没有指定结束位置，所以切到字符串的最后一个元素
?s3='!'
?newstr=s1+s3+s2#hello!python
?print(s1)
?print(s2)
?print(newstr)
?print(id(s1))
?print(id(s2))
?print(id(s3))
?print(id(newstr))#切片id各不相同
??
?print('-------切片[start:stop:step]  ------')
?print(s[1:5:1])#从1开始截到5，不包含5，步长为1
?print(s[::2])#默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
?print(s[::-1])#默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
?print(s[-6::1])#从索引为-6开始，到字符串的最后一个元素结束，步长为1，python

切片id各不相同

5.格式化字符串

?#格式化字符串
?#1. %占位符
?name='张三'
?age=20
?print('我叫%s,今年%d岁' %(name,age))#我叫张三,今年20岁
??
?#2. {}
?print('我叫{0},今年{1}岁'.format(name,age))#我叫张三,今年20岁 ?
??
?#3.f-string
?print(f'我叫{name},今年{age}岁')#我叫张三,今年20岁

?print('%10d' %99)#10表示宽度# ? ? ?  99（前面8个空格）
?print('%.3f'%3.1415926)# ? .3表示保留三位小数
?#同时表示宽度和精度'
?print('%10.3f'%3.14595555)#总宽度为10，小数点后三位
??
??
?print('hellohello')

?print('{0}'.format(3.1415926))#花括号是占位符，占的3.1415926的位置 ? ? ? ? ? ? ? ?  3.1415926
?print('{0:.3}'.format(3.1415926))#.3表示一共三位数 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  3.14
?print('{0:.3f}'.format(3.1415926))#.3d表示是3位小数 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 3.142
?print('{:10.3f}'.format(3.1415926))#10表示宽度为10 #同时设置宽度和精度，一共是10位，其中三位是小数 ? ? ? ? ? ? ? ? ? ? ? ? ? ? 3.142
?#0表示占位符的顺序，也可以不写

6.字符串的编码与解码

s='天涯共此时'
#编码
print(s.encode(encoding='GBK'))#在GBK这种编码格式中，一个中文占两个字节
#b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1' b表示二进制byte 后面刚好十个（五个字 一个字两字节）
print(s.encode(encoding='UTF-8'))#在 UTF-8这种编辑格式中，一个中文占三个字节
#b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'  多了五个

#解码
#byte代表一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')# 编码
print(byte.decode(encoding='GBK'))#解码 天涯共此时
#print(byte.decode(encoding='UTF-8'))#ERROR 因为编码格式要和解码格式相同

7.函数的定义与调用

def calc(a,b):#a b成为形式参数 简称形参，形参的位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)#10 20 称为实际参数的值，简称实参，实参的位置实在函数的调用处
print(result)

res=calc(b=10,a=20)#等号左侧变量名称成为 关键字参数
print(res)

8.位置实参，关键字实参

9.函数参数传递的内存分析

def fun(arg1,arg2):
    print('arg1',arg1)
    print('arg2',arg2)
    arg1=100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2)#将位置传参，arg1 arg2，是函数定义出的形式参数，n1 n2是函数调用处的实参，总结：实参名称与形参名称可以不一致

print('n1',n1)
print('n2',n2)
'''在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值 arg1的修改不会影响n1的值
如果是可变对象，在函数体的修改会影响实参的值     arg2的修改会影响到n2的值'''

10.函数的返回值

def fun(num):
    odd=[]#存奇数
    even=[]#存偶数
    for i in num:#遍历列表
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))

'''
函数的返回值
1.如果函数没有返回值（函数执行完后，不需要给调用处提供数据） return可以不写
2.函数的返回值如果是一个，直接返回原值
3.函数的返回值如果是多个，返回的结果为元组
'''

def fun1():#直接输出就行了，没返回值
    print('hello')
    #renturn

fun1()


def fun2():
    return'hello'

res=fun2()
print(res)

def fun3():
    return'hello','world'
print(fun3())

'''函数在定义时，是否需要返回值，视情况而定'''