python这部分的学习，我本身是充满信心的，毕竟本身工作当中用到了pandas，但是在学习过程中还是发现了许多不足，例如循环部分while True，高级函数用法等这些细节知识点，现在通过复盘再把这些知识点总结一下，不理解的地方再多思考和练习，最终达到巩固和熟练基础知识的目的。

一、输出

1 格式化输出

常用格式化字符：
%s-----字符串
%d-----有符号十进制整数
%06d-----表示输出的整数显示位数，不足的地方使用0补全
%-6d------做左对齐
%f-----浮点数
%.2f-----表示小数点后只显示两位
%%-----%

2 补充和思考

'-' ：指定左对齐。
'+' ：表示数值总要带符号，正数带“+”号，负数带 “-” 号。
0 ：表示不补充空格，而是补充 0。
示例如下：

num = 39
print("num is: %06d" % num)      #  最小宽度为6，左边不足的用 0 补充，输出：num is: 000039
print("pi is: %010.4f" % pi)      # 最小宽度为10位，小数点后保留4位，右对齐，左边补0，输出：pi is: 00003.1416
name = 'Michael'
print("the name is: %.4s" % name)    # 字符串保留4个字符，输出：the name is: Mich
print("the name is: %8.2s" % name)  # 保留2个字符，最小宽度为8位，输出：the name is:       Mi

二 if条件和逻辑语句

1 注意知识点1

当使用if条件语句时，最后一行打印无论是否满足条件都会打印。代码如下：

age = 18
if age >= 18:
    print("可以进入网吧嗨皮")
else:
    print("还没有长大，回家吧")
# 无论条件是否满足都会执行
print("这句代码什么时候执行？")

2 注意知识点2

当定义一个布尔型变量 is_employee，编写代码判断是否是本公司员工的写法如下：

is_employee = False

if not is_employee: # 等于if is_employee is not True:

    print("do not enter")

3 注意知识点3

elif 和 else 都必须和 if 联合使用，而不能单独使用，
elif 强调的是 并列的多种结果，
逻辑运算符 强调的是 与某个结果有关的 多个条件

4 注意知识点4

if 条件语句中使用多个条件的逻辑运算时要分别用（）括起来：

# 假定电脑就只会出石头
player = int(input("请出拳 石头（1）／剪刀（2）／布（3）："))
computer = 1

# player满足赢的条件，注意用括号分别括起来
if ((player == 1 and computer == 2) or
    (player == 2 and computer == 3) or
    (player == 3 and computer == 1)):

    print("you win")
elif player == computer:
    print("once again")
else:
    print("you lose")

三 循环语句

1 while 基本语法规则

变量设置初始值 # 注意！

while 条件(判断 变量是否满足条件):
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...

    修改变量 # 注意！

举例(注意在变量设置初始值和修改变量的用法)：

# 1. 定义重复次数计数器
i = 1

# 2. 使用 while 判断条件
while i <= 10000:
    # 要重复执行的代码
    print("媳妇儿，我错了")
    # 处理计数器 i
    i = i + 1

2 break用法

在循环过程中，如果 某一个条件满足后，不再希望循环继续执行，可以使用 break 退出循环

i = 0
while i < 10:
    # break 某一条件满足时，退出循环，不再执行后续重复的代码
    # i == 3
    if i == 3:
        break
    print(i)
    i += 1
print("over")

3 continue用法

在循环过程中，如果 某一个条件满足后，不希望执行本次循环代码，但是又不希望退出循环，可以使用 continue。也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行

i = 0
while i < 10:
    # 当 i == 7 时，不希望执行需要重复执行的代码
    if i == 7:
        # 在使用 continue 之前，同样应该修改计数器
        # 否则会出现死循环
        i += 1
        continue
    # 重复执行的代码
    print(i)
    i += 1

4 循环嵌套用法

复习例子a

row = 1
while row <= 5:
    # 假设 python 没有提供字符串 * 操作
    # 在循环内部，再增加一个循环，实现每一行的 星星 打印
    col = 1
    while col <= row:
        print("*", end="")
        col += 1
    # 每一行星号输出完成后，再增加一个换行
    print("")
    row += 1

复习例子b

# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
    # 定义起始列
    col = 1
    # 最大打印 row 列
    while col <= row:
        # end = ""，表示输出结束后，不换行
        # "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
        print("%d * %d = %d" % (col, row, row * col), end="\t")
        # 列数 + 1
        col += 1
    # 一行打印完成的换行
    print("")
    # 行数 + 1
    row += 1

5 作业中注意点 while True:

while True:作为无限循环，经常在不知道循环次数的时候使用，并且需要在循环内使用break才会停止。采用该语句的核心思想是：如果出现错误的话，还可以继续循环，例如在用户输入用户名或密码错误的情况下返回到开始部分，请求继续输入。在作业中是猜年龄当尝试3次后，还没猜对，但还想继续玩，while True就可以继续让其猜3次，以此往复。

age_of_oldboy='65'
count=0
while True:
  if count == 3:
      choice=input('继续Y/N?: ')
      if choice == 'Y' or choice == 'y':
          count=0
      else:
          break # 重要！！
  guess=input('请输入年龄: ')

  if guess == age_of_oldboy:
      print('你猜对啦')
      break # 重要！！

  count+=1

五 列表

1列表的增删改查

列表.png

a.增加元素

1) 列表.insert(索引，数据): 在指定位置插入一个值

2) 列表.append(数据)：在末尾追加一个值，这个最常用

3) 列表.extend(Iterable)：将另一个列表（也可以）的全部内容追加到末尾

注意知识点：使用 append 追加的是将后面的列表作为一个整体追加到最后了，而使用 extend 追加的是将里面的元素依次追加到最后。

b. 删除元素：

1) del 列表[索引]：删除指定索引元素

2）列表.remove(数据)

3）列表.pop()：可指定索引删除，不指定会删除最后一个

注意知识点：pop 函数还有返回值，会返回被删除的值

c. 修改元素：直接指定索引赋值，就是修改元素内容

d. 查询元素：

1)* 列表[索引]：根据索引获取（查询）值*

2) 列表.index(数据)：查询给定值的索引，即想要知道元素的位置，如果查询元素有多个相同值只会返回第一个值出现的记录

3) 列表.count(数据)：查询值出现的次数

4) len(列表)：有多少个元素

5) if 数据 in 列表：判断元素是否在列表中，用作条件语句中

e. 元素排序：list.sort()

注意知识点：sort 方法还有一个参数，key，这个参数是传递函数方法名的，可以传入自定义的函数名或者是匿名函数

list=[5,7,9,0,4,'8']
# 这里是使用 int 函数，意思是将里面可以转换为数字的字符串转换成数字来排序，如果转换不成功会报错，如‘8d’ 显示是不能转换为数字类型的
list.sort(key=int,reverse=True)
print(list)

2 列表的循环遍历

a while

while循环实现列表的遍历：打印出列表的所有元素，i 是起到循环得到索引值的作用

i = 0
name_list = ["zhangsan", "lisi", "wangwu"]
list_count = len(name_list)
while i < list_count:
    name = name_list[i]
    print(name)
    i += 1

b for

for 循环其实就是专门用来对高级变量进行循环遍历的（如元组、字典）

for name in name_list:
    循环内部针对列表元素进行操作
    print(name)

3 list 应用场景

• 列表 一般只存储相同类型的数据
• 通过 for循环，在循环体内部，针对列表中的每一项元素，执行相同的操作

六 元组

注意：元组的元素不能改变,但是，如果元组中的元素如果为列表/字典时，则可以修改列表/字典中的元素的值,数据之间使用，分隔。

1 元组的查询

查询.png

tuple=(5,7,3,7)

print(tuple)
# 根据索引查询值
print(tuple[0])
# 根据值查询索引
print(tuple.index(7))
# 求值出现的次数
print(tuple.count(7))
# 求元组的长度：即元素个数
print(len(tuple))
# for 遍历
for n in tuple:
    print(n)

2 应用场景：自动组包

自动组包的默认类型：组包后是一个元组，可以用来快速交换两个变量的值

a=3
b=4
# 赋值的右侧有多个数据时，会自动组包成元组
# 如果赋值的左侧接收的变量和右侧的变量的个数一致，就会自动解包，一一对应赋值
b,a=a,b
# 注意：右侧组包后相当于是变成了一个元组
# b,a=(a,b)
print(a)
print(b)

# 如果个数不一致左边就得到一个元组
c=a,b
print(c)
print(type(c))

七 字典

字典使用键值对(key、value对)存储数据，键值对之间使用,分隔

• 键 key 索引：注意索引不再是 0，1，2... 了，虽然可以用数字，但是一般使用字符串
• 值 value 数据
• key:value 之间使用：分隔
• 键必须是唯一的：如果有多个，后者会覆盖前者
• 值 可以取任何数据类型，但键只能字符串、数字或元组
• 字典是无序对象的集合

1 字典的增改删查

字典.png

a 增加元素

1) 字典[键] = 数据

键不存在，会添加键值对；键存在，会修改键值对的值

b 删除元素

1） del 字典[键]

2) 字典.pop(键)

注意：pop 删除成功了会返回被删除的值

3) 字典.clear

c 修改元素

1) 字典[键] = 数据

2) 字典.setdefault(键，数据)

3) 字典.update(字典2)

d 查询元素

1）字典[键]：注意不能根据值来查询键

2）字典.get(键)

2 字典的遍历

• 字典.keys()、字典.values()、
• 字典.items()：返回的是一个元组
• 以上三个都是视图对象类型，可以用for遍历，也可以转换为list
• 直接对一个字典进行 for 遍历，取出来的是 键

3 应用

• 使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
• 将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

八 函数

1 定义

• 定义函数：在函数中编写代码，实现功能
• 调用函数：执行编写代码
  定义函数的格式如下：

def 函数名():

    函数封装的代码
    ……

函数的执行顺序总结：

​ 程序代码始终都是顺序执行的，也就是从第一行到最后一行，但在程序执行到 def func 定义函数的语句时不会运行函数，而是将函数名作为标识符添加到内存中而不会运行函数里面的代码。而当程序继续往下，到调用函数的语句时，就会到内存中查询是否有该函数，如果有就调用函数名对应的函数代码。这里也有一个要注意的事项，就是函数调用必须在函数定义后，不然找不到函数会报错。

注意：函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行

2 函数的参数

a 如何处理只能固定数值相加的函数？？

def sum_2_num():

    num1 = 10
    num2 = 20
    result = num1 + num2

    print("%d + %d = %d" % (num1, num2, result))

sum_2_num()

解决：

def sum_2_num(num1, num2):

    result = num1 + num2

    print("%d + %d = %d" % (num1, num2, result))

sum_2_num(50, 20)

总结：函数的参数增加了函数的通用性，针对相同的数据处理逻辑，能适应更多的数据

• 函数内部，把把参数当做 变量 使用，进行需要的数据处理
• 函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递

b 形参和实参

• 形参：定义 函数时，小括号中的参数，是给真实数据占位用的，在函数内部 作为变量使用
• 实参：调用 函数时，小括号中的参数，是传递到 函数内部 的 真实数据

a = 5  

def test1(a): 
    # 这里 a 是形参，是在函数内部定义的，作用域只在函数内部
    a += 1
    print("%d" % a)

test1(2)  
# 这里因为形参的作用域不到这里，所以这个 a 是外面的 a
print("%d" % a)

3 函数返回值

def sum_2_num(num1, num2):
    """对两个数字的求和"""

    return num1 + num2

# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)

print("计算结果是 %d" % result)

a 关于return

• return 后面可以不跟值

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)
    return

• 函数中凡是代码执行到 return 时，都会终止函数的执行，返回到函数调用的代码处。所以可以灵活利用 return 结束程序

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)

    return
    # 这行代码不会执行了
    print('不会执行这行代码')

res=func_sum()
print(res)

4 四种函数类型

1 无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

def print_menu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

2 无参数，有返回值的函数

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

# 获取温度
def get_temperature():
    # 这里是获取温度的一些处理过程
    # 为了简单起见，先模拟返回一个数据
    return 24

temperature = get_temperature()
print('当前的温度为:%d' % temperature)

3 有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

4 有参数，有返回值的函数

# 计算1~num的累积和
def calculate_num(num):
    result = 0
    i = 1
    while i < =num:
        result = result + i
        i += 1
    return result

result = calculate_num(100)
print('1~100的累积和为:%d' % result)

5 列表推导式

• 基本方式：
• a=[x for x in range(4)]
• b=[x for x in range(1,7) if x%2!=0]
• d=[(x,y) for x in range(1,4) for y in range(3,5)]

6 匿名函数

a 语法： lambda [参数列表]: 表达式

b 要点

lambda 表达式的几个要点：

• lambda 表达式必须使用 lambda 关键字定义。
• 在 lambda 关键字之后、冒号左边的是参数列表，可以不给参数，也可以给多个参数。多个参数用逗号分隔，冒号右边是 lambda 表达的返回值。
• lambda 表达式也叫做匿名函数，也是单行函数体的函数。

c 应用

• 对于单行函数，使用 lambda 表达式更简洁，省去定义函数的过程。
• 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高性能。

# 计算平方
x = map(lambda x: x * x, range(5))
 print([i for i in x])
# 计算偶数的平方
y = map(lambda x: x * x if x % 2 ==0 else 0, range(5))
print([i for i in y])

注意：Lambda函数能接收任何数量的参数但只能返回一个表达式的值，匿名函数不能直接调用print，因为lambda需要一个表达式

d 函数作为参数传递

# 定义一个函数
def fun(a, b, opt):
     print("a = %s" % a)
     print("b = %s" % b)
     print("result =%s" % opt(a, b))

# 调用函数
fun(1, 2, lambda x,y:x+y)

e 作为内置函数的参数

# 作为内置函数的参数
stus = [
    {"name": "zhangsan", "age": 18},
    {"name": "lisi", "age": 19},
    {"name": "wangwu", "age": 17}
]
# 字典中每个key
a = map(lambda x: x['name'],stus)
print([i for i in a])
# 按name排序
stus.sort(key=lambda x:x['name'])
print(stus)
# 按age排序
stus.sort(key=lambda x:x['age'])
print(stus)

九 高级函数

1 局部变量

• 局部变量，就是在 函数内部定义的变量
• 局部变量的作用域只在函数内部

2 全局变量

• 在函数外边定义的变量叫做 全局变量
• 全局变量能够在所有的函数中进行访问

# 定义全局变量
a = 100

def test1():
    print(a)

def test2():
    print(a)

# 调用函数
test1()
test2()

• 函数内修改全局变量: global 声明

a = 10

def test():
    global a
    a = 5  # 修改全局变量
    print("函数内a：%d" %a)

test()
print("函数外a：%d" %a)

3 函数返回值二

a 多个return

def is_even_num(num):
    """判断奇偶数"""
    if num % 2 == 0:
        return True
    else:
        return False

b 多个返回值

def func2():
    return 1,1.5

#返回多个数据时，自动将数据组包成元组
a = func2()
print(a)

#用多个变量接收返回值，python会自动将元组 拆包 成单个数据
a,b = func2()
print(a)
print(b)

a,b,c = 1,1.5,"hello"
print(a)
print(b)
print(c)

当返回多个数据时，python会自动将数据 组包 成元组,如果使用多个变量接收返回值，python会自动将元组 拆包 成单个数据

4 函数参数二

a 默认参数

• 形参设定默认值 称为 默认参数
• 调用函数时，如果没有传入默认参数对应的实参，则实参使用默认值。

def printinfo(name, age = 35):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

# 调用printinfo函数
printinfo("miki")
printinfo("miki", 20)

• 注意：默认参数一定要位于参数列表的最后面。

b 关键字参数（缺省参数）

调用函数时，实参可以指定对应的形参，称为 关键字参数

def printinfo(name, age):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

printinfo(age=9,name="miki" )

c 可变参数

1) args 元组可变参数

• 函数可以定义 可变参数，用于接收任意数量的参数
• 可变参数的前边需要添加*，用于提示python解释器该参数为可变参数
• 使用可变参数直接用args即可（不需要加*）
• 可变参数的本质是 将传递的参数包装成了元组

def sum_num(a, b, *args):  
    result = a + b
    for temp in args:
        result += temp

    return result

sum_num(1, 2, 3, 4, 5, 6)

# 关键字参数一旦使用，所有实参都要使用，除非该实参对应的是可变参数
# sum_num(1, 2, 3, 4, a=5)
# sum_num(a=5, b=4)

2）kwargs 字典可变参数

• 字典可变参数：可以接受多余的关键字参数
• 字典可变参数必须要放在形参的最后面
• 定义参数时需要在变量名前添加两个*
• 这种可变参数会将 不存在的关键字参数包装成字典

def sum_num(a, b, *args, **kwargs):  
    print(a)
    print(b)
    print(args)
    print(kwargs)

sum_num(1, 2, 3, 4, 5, 6, mm=5, nn=6)

ｄ函数的参数传递机制

Python 中函数的参数传递机制都是“值传递”，就是将实际参数值的副本（复制品）传入函数，而参数本身不会受到任何影响。示例如下：

# 传递可变参数
def sum_num(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)

def test(*args, **kwargs):
    print(args)
    print(kwargs)

sum_num(1, 2, 3, 4, 5, 6, 7, mm=5, nn=6)

5 总结

Python 中的函数是“一等公民”，因此函数本身也是一个对象，函数即可用于赋值，也可用作其函数的参数，还可作为其他函数的返回值。