字符串比较：字符串对应的ascii进行比较
2.多个字符的字符串进行比较：从前往后逐个字符进行比较，一旦哪个位置的字符出现了大小关系就结束比较。
函数参数
一.参数介绍
1.函数为什么要有参数：因为内部的函数体需要外部的数据
2.怎么定义函数的参数：在定义函数阶段，函数名后面()中来定义函数的参数
3.怎么使用函数的参数：在函数体中用定义的参数名直接使用
1. 形参：在定义函数的时候，()中出现的参数，参数本身没有意义，有实参赋予形参值后，该形参就具备了意义 补充：有默认值的形参，在没有被实参赋值，具备的是自身意义，但一旦被实参赋值，意义同实参 2.实参：有实际意义的参数 -- 在函数调用的时候，()中传入的参数 3.形参是对实参的值拷贝 4.形参与实参可以重名，但是代表的是两个不同的变量 5. 不可变类型，形参发生重指向，实参不变 def fn(num): print('1>>>:', num) # 10 num = 20 print('2>>>:', num) # 20 num = 10 fn(num) print('3>>>:', num) # 10 可变类型，形参发生值的内部变化，实参变，两个指向的是同一个地址 def func(ls): print('1>>>:', ls) # [10] ls.append(20) print('2>>>:', ls) # [10, 20] ls = [10] func(ls) print('3>>>:', ls) # [10, 20]
实参分为：位置实参 关键字实参 def fn(a, b): print(a, b) 方式1：拿实际值进行传参（本质就是位置传参） fn(10, 20) # 10 => a | 20 => b 方式2：位置实参传参：形参与实参进行位置一一对应，eg:一号为的实参一定传给一号位的形参 a = 100 b = 200 fn(a, b) # a:100 => a | b:200 => b fn(b, a) # b:200 => a | a:100 => b 方式3：拿关键字实参进行传参：指名道姓进行传参 - 传参的过程过指名道姓形参 # 明确：形参名目前为a和b fn(a=1000, b=2000) # a:1000 => a | b:2000 => b fn(b=2000, a=1000) # b:2000 => b | a:1000 => a a = 666 b = 888 # 前面的是形参名，后面的是传递的实参名 fn(a=a, b=b) # a:666 => a | b:888 => b # 位置传参：一定按照位置，且个数要一一对应进行传参 # 关键字传参：指名道姓进行传参，个数一致位置可以改变进行传参 # 位置关键字组合传参规则：必须先传位置实参，再传关键字实参
1.六大分类： # 1.无值位置形参(位置形参)：可以被位置与关键字实参进行传参，必须传值 # 2.有值位置形参(默认形参)：可以被位置与关键字实参进行传参，可以不用传参采用默认值 # 3.可变长位置形参：可以接受前两个没有接收完位置实参，接收的个数可以为0~n个，0个是就是空元组 # 4.无值关键字形参：只能由关键字实参进行传参，必须传值 # 5.有值关键字形参：只能由关键字实参进行传参，可以不用传参采用默认值 # 6.可变长关键字形参：接收4，5没有接收完的关键字实参，接收的个数可以为0~n个，0个是就是空字典 2.声明顺序： # 位置形参:a -> 默认形参:b -> 可变长位置形参:args -> 有无默认值关键字形参:cde -> 可变长关键字形参:kwargs def fn(a, b=10, *args, c, d=20, e, **kwargs): pass 3.注意点： # 1.可变长位置形参只能接受位置实参，要想被附上值，前面的有值位置形参的默认值没有多大意义 # 2.args与kwargs是可变长形参的变量名，所以可以自定义，但约定俗成就用它俩 4.常出现的组合 def f1(*args, **kwargs): pass def f2(a, b=10, **kwargs): pass def f3(a, *args, **kwargs): pass def f4(a, *, x, **kwargs): pass def f5(a, *args, x, **kwargs): pass 5.使用法则： # 1.所有位置形参全部采用位置实参进行传值 # 2.所有关键字形参全部采用关键字实参进行传值 # 3.不管位置还是关键字形参，全部按照顺序进行传参
1.所有的函数都有返回值,无论你写不写return python中所有的函数都有返回值 不写的情况下默认返回None 2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行 3.函数内要想返回给调用者值 必须用关键字return 示例1：不写return:函数默认返回None # def func(): # print('hahaha') # res = func() # print(res) 示例2： # 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行 # 只写return 返回的也是None(None就表示什么都没有) # def func(): # l = ['jason','egon','tank'] # while True: # for i in l: # if i == 'egon': # 当i为egon的时候 直接结束函数运行 # # break # return # # print('asdasdkljlsjadl') # 这一行代码拥有都不会运行 # print(i) # res = func() # print(res) 示例3： # 写return None:跟上面的只写return是一样的 # def func(): # return None # res = func() # print(res) 示例4：写return返回一个值:这个值可以是python任意数据类型 # def func(): # return '123' # def func1(): # return [1,2,3] # def func2(): # return {'name':'jason'} # def func3(): # return (1,) # def func4(): # return {1,2,3,4,5} # def func5(): # return True # print(func(),func1(),func2(),func3(),func4(),func5()) 示例5： # 写return返回多个值:return会自动将多个值以元组的形式返回给调用者 """ 1.为什么组织成元祖返回 函数不希望自己处理的结果被修改 2.如何不返回元祖 """
def func():
return 1,2,3,4 # 返回的是(1, 2, 3, 4)
# res = func()
# print(res)
def func1():
return 'a','b','c' # ('a', 'b', 'c')
res = func1()
print(res)
def func2():
return [1,2,3],[1,2,3],[1,2,3] # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)
def func3():
return {'name':'jason'},{'username':'tank'},{'user_name':'egon'} # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res2 = func3()
print(res2)
# 返回多个值 并且不想让return帮你做处理 自己手动加上你想返回的数据类型符号
def func4():
return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)
函数在定义阶段 内部所使用的变量的查找顺序就已经确定了 不会因为调用的位置的变化 而影响到内部的值(暂时可忽略 函数无论在什么地方被调用 都会跑到函数定义阶段去执行代码 形参中用到的值都是往函数定义阶段代码往上找 a = 100 def fn(num=a): print(num) # 100 a = 200 fn()
1.单双列容器和打散机制 # *单列容器 会打散单列容器 # **双列容器 会打散双列容器 # 字符串也可以被打散