python学习日记79-89

隔离日记DAY6

 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']

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

 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  !不行

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

 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，这一部分也比较好理解。

 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内存地址全相同 字符串驻留机制：当发现有相同字符串时，不会再创建新的字符串，而指向相同字符串的空间

 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各不相同

 #格式化字符串
 #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表示占位符的顺序，也可以不写

s='天涯共此时'
#编码
print(s.encode(encoding='GBK'))#在GBK这种编码格式中，一个中文占两个字节
#b'xccxecxd1xc4xb9xb2xb4xcbxcaxb1' b表示二进制byte 后面刚好十个（五个字 一个字两字节）
print(s.encode(encoding='UTF-8'))#在 UTF-8这种编辑格式中，一个中文占三个字节
#b'xe5xa4xa9xe6xb6xafxe5x85xb1xe6xadxa4xe6x97xb6'  多了五个

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

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)

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的值'''

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())

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

倦了.....晚安