初学python第六天

一、字符串格式化

　　用法：

　　　　tp="i am {},age {},hobby {}".format("aikang",21,"python")

代码如下：

tp = "i an {},age {},hobby {}".format('艾康',21,"python")
print(tp)
    结果：i an 艾康,age 21,hobby python

　　说明:

　　　　不对称会报错：就是说如果空出来要引用进去的空位和后边.rormat定义出来的不对称就会报错。

代码:

tp = "i an {},age {},hobby {}".format('艾康',"python")
print(tp)
    结果：Traceback (most recent call last):
  File "F:/pythonTest/Test02/format字符串格式化.py", line 29, in <module>
    tp = "i an {},age {},hobby {}".format('艾康',"python")
IndexError: tuple index out of range

Process finished with exit code 1
    原因：需要三个却只定义了两个

　　索引引用：

　　　　可以按照索引来赋值

代码：

tp = "i an {2},age {1},hobby {0}".format('艾康',"python",21)
print(tp)
    结果：i an 21,age python,hobby 艾康
        结果和通过顺序定义是一样的

　　　　通过索引可以不一一对称，取一个值也是可以的，如果索引超出范围会报错

代码：

扫描二维码关注公众号，回复： 4816171 查看本文章

tp = "i an {2},age {2},hobby {2}".format('艾康',"python",21)
print(tp)
    结果：i an 21,age 21,hobby 21
    

索引超出实例：
tp = "i an {3},age {2},hobby {2}".format('艾康',"python",21)
print(tp)
    结果：Traceback (most recent call last):
  File "F:/pythonTest/Test02/format字符串格式化.py", line 29, in <module>
    tp = "i an {3},age {2},hobby {2}".format('艾康',"python",21)
IndexError: tuple index out of range

Process finished with exit code 1
    说明：这里第一个空位引用了索引3定义只有0,1,2所以报错

　　用等号赋值：

代码：

tp = "i an {name},age {age},hobby {hobby}".format(name='aikang',age=21,hobby='python')
print(tp)
    结果：i an aikang,age 21,hobby python

 　　元组赋值：

代码：

tp = "i an {0[0]},age {0[1]},hobby {0[2]}".format(['aikang',21,'python'])
print(tp)
    结果：i an aikang,age 21,hobby python

二、函数（def）

　　定义： def 函数名(): 

　　　　  函数分为有参函数和无参函数。有参函数是括号里带有参数的函数，"""

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　"""

　　　　　　过程就是没有返回值的函数

有参代码：

def foo(x):
    """

    :param x: 传入为整数
    :return: 返回结果
    """
    return x*2+1
    # return内部：y = x*2+1  return y
# 打印函数地址
print(foo)
# 给x赋值
a = foo(5)
# 打印结果
print(a)
    结果：<function foo at 0x00000226C3DA9620>
                11

 无参需要自己定义参数

代码：

def foo():
    """

    :return: 计算结果
    """
    x=5
    y = x*2+1
    return y
print(foo())
    结果：11

　　多参函数：多参时定义要一一对应

多参代码：省略函数说明

def foo(x,y):
    # 用ser来接收
    ser = x**y
    return ser
a = foo(3,4)
print(a)
    结果：81

 　　用等号赋值时，位置不用一一对应，数量缺一不可多一不可

代码：省略函数说明

def foo(x,y,z):
    # 用ser来接收
    ser = x*z*y
    return ser
a = foo(x = 2,y = 10,z = 8)
print(a)
    结果：160

　　补充：位置参数必须在关键字参数左边

代码：省略函数说明

def foo(x,y,z):
    # 用ser来接收
    ser = x*z*y
    return ser

a = foo(2,y = 10,z = 8)
print(a)
    结果：160

a = foo(2,10,z = 8)
print(a)
    结果：160
a = foo(x=2,10,8)
print(a)
    结果：报错
a = foo(x=2,10,z=8)
print(a)
    结果：报错
a = foo(2,y=10,8)
print(a)
    结果：报错

　　默认参数：先赋值在改值。

代码：

def foo(x,y="None"):
    """
    
    :param x: 测试
    :param y: 测试
    :return: 测试打印不返回值
    """
    print(x)
    print(y)
# 只定义一个
foo(10)
    结果：10
            None    

def foo(x,y="None"):
    """

    :param x: 测试
 :param y: 测试
 :return: 测试打印不返回值
 """
 print(x)
 print(y)
# 赋予新值
foo(10,y=20)
　　结果：10
　　　　　20

　　参数组：**字典，*元组：

代码：*号代表遍历一遍并用元组储存

ef foo(x,*y):
    # 加了*号后，x取用一个值别的都赋值给*y,y用元组储存
    print(x)
    print(y)
    # 调用自己并赋值
foo(3,10,'nihao''aikang')
    结果：3
            (10, 'nihaoaikang')        

代码：**接收的是字典

def foo(x,**y):
    # 加了*号后，x取用一个值别的都赋值给*y,y用列表储存
    print(x)
    print(y)
    # 调用自己并赋值
foo(3,c =10, a=10,b=20)
    结果：3
{'c': 10, 'a': 10, 'b': 20

并用代码：不是字典形式的全部赋给*一个参数不能传两个值比如给两个x赋值。

def foo(x,*y,**z):
    print(x)
    print(y)
    print(z)
    # 调用自己并赋值
foo(3,'aikang','nihao',123,c =10, a=10,b=20,)
    结果：3
('aikang', 'nihao', 123)
{'c': 10, 'a': 10, 'b': 20}

代码：后边加kwargs无所不能接收

# 后边固定kwargs，无所不能接收
# **带名字的都给它
# def test(x,*args,**kwargs):
#     print(x)
#     print(args)
# test(1,y=2,z=3)

全局变量与局部变量：

　　说明：全局变量可以全局引用，局部变量只能子类引用，global是关键字，用来给全局变量赋予新值

代码：

#没用关键字钱
name='aikang'
def foo():
    name='huilanyan'
    print(name)
print(name)
foo()
print(name)
    结果：
aikang
huilanyan
aikang

#用关键字后
name='aikang'
def foo():
    global name
    name='huilanyan'
    print(name)
print(name)
foo()
print(name)
    结果：
    aikang
huilanyan
huilanyan

代码：如果用列表定义可以添加

name = ['aikang']
def foo():
    name.append('is')
    print(name)
foo()
    结果：['aikang', 'is']

　　前项引用：

　　　　通过后边的函数引用前边的函数

代码：运行顺序不变，直到运行到调用前项

def foo():
    print('小白兔')
def aoo():
    print('白了又了白')
    foo()
aoo()
    结果：
白了又了白
小白兔

　　递归：基本没听明白，只记得一些笔记

笔记：

import（导入包） time（时间）

time.sleep(睡眠时间)

1、递归要有明确的结束条件

2、每次进入更深一层递归时，问题规模要比上次递归减少

3、递归效率不高，递归层次过多会导致栈的溢出（计算机中函数调用）是通过栈（stack）这种数据结构实现的，每次进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以递归调用的次数过多，就会导致栈溢出。

代码：

　

 

　　作用域：

代码：

name = 'aikang'
def foo():
    name = 'hui'
    def aoo():
        name='lan'
        def boo():
            print(name)
        return boo
    return aoo
foo()()()

　　匿名函数：

　　　　定义：关键字：lambda

　　　　　　　用法lambda x:x+1

　　　　　　　　默认了return

代码：

# lambda x:x+1
# 为了说明
a = lambda x:x+1
# 打印地址
print(a)
# 赋值x
print(a(10))
    结果：11

　　练习：要求在name后边追加‘_ok’

代码：

name = 'aikang'
def foo():
    return name+'_ok'
print(foo())
    结果：aikang_ok