PYTHON1.day08

day07 回顾:
   两个容器:
     元组 tuple(不可变的序列)
     字典 dict(可变的无序的容器)
元组
   序列: 字符串 str, 列表 list, 元组 tuple, bytes, bytearray

  元组的表示方式:
     ()  (20,)   (1, 2 ,3)   20,   1,2,3
   构造函数:
     tuple()   tuple(可迭代对象)
   元组的运算:
     +  +=   *   *= 
     < <= > >= == !=
     in / not in
     索引取值和切片取值
   len(x), max(x), ..........
   reversed(x)  sorted(x, reverse=False)

字典:
   可变的容器,字典的存储是无序的
   键值对方式存储, (键: 不可变对象, 值: 可以是任意对象)

  字面值:
     {1: "hello"}
     {'name': 'xiaozhang', 'age': 20, 'score':100}
   构造函数
     dict()
     dict([(1, "壹"), (2, '二')])
     dict(name='xiaozhang', age=20, score=100)
   字典的运算:
     键索引取值:
        v = 字典[键]
     赋值:
        字典[键] = v
     del 字典[键]
     ==   != 

  能用于字典的函数:
     len(x), max(x), min(x), sum(x), any(x), all(x)
   字典的方法:
     D.clear()
     D.pop(key)
     D.copy()
     D.update(d2)  更新
     D.get(key, default=None)  # 取值(不会报错)
     D.keys()
     D.values()
     D.items()

  字典推导式
     {键表达式: 值表达式 for 变量 in 可迭代对象 if 真值表达式}

day08笔记
   集合 set
     集合是可变的容器
     集合内的数据对象都是唯一的(不能重复多次的)
     集合是无序的存储结构,集合中的数据没有先后关系
     集合内的元素必须是不可变对象
     集合是可迭代对象(可以用for等遍历)
     集合是相当于只有键,没有值的字典(键则是集合的数据)

  创建空集合:
     set()   
   创建非空集合的字面值:
     s = {1, 2, 3}

  集合的构造函数: set
     set() 创建一个空的集合对象(不能用{}来创建空集合)
     set(iterable)  用可迭代对象创建一个新的集合对象

  示例:
     s = set()
     s = {1, 2, 3, 4}
     s = set("ABC")
     s = set("ABCABC")  # s = {'A', 'B', 'C'}
     s = set([1, 0, 3.14, 0.618])
#    s = {1, 2, [3, 4], 5}  # 报错,集合内不能放列表和字典
#    s = {1, 2, {3, 4}, 5}  # 出错集合是可变对象
    

集合的运算:
   交集&, 并集|, 补集-, 对称补集^, 子集<, 超级>

  & 运算符生成两个集合的交集
    s1 = {1, 2, 3}
     s2 = {2, 3, 4}
     s3 = s1 & s2  # s3 = {2, 3}

  | 生成两个集合的并集
     s1 = {1, 2, 3}
     s2 = {2, 3, 4}
     s3 = s1 | s2  # s3 = {1, 2, 3, 4}
   - 生成两个集合的补集
     s1 = {1, 2, 3}
     s2 = {2, 3, 4}
     s3 = s1 - s2  # 生成属于s1,但不属于s2的所有元素的集合

  ^ 生成两个集合的对称补集
    s1 = {1, 2, 3}
     s2 = {2, 3, 4}
     s3 = s1 ^ s2  # s3 = {1, 4} 

  > 判断一个集合是另一个集合的超集
   < 判断一个集合是另一个集合的子集
    s1 = {1, 2, 3}
     s2 = {2, 3}
     s1 > s2   # True, s1为s2的超集
     s2 < s1   # True, s2为s1的子集

  == != 集合相同或不同
     s1 = {1, 2, 3}
     s2 = {2, 3, 1}
     s1 == s2  # True 相同
     s1 != s1  # False
   >=  <=  超集或相同, 子集或相同

  in / not in 运算符:
     等同于字典, in 用于集合中,当某个值存在于集合中返回True,否
     则返回False
     not in 与 in 返回值相反

    说明:
       集合的in / not in 运算符查找速度比较快

  能用于集合的内建函数:
     len(x)  max(x)  min(x)  sum(x)  any(x)   all(x)

  集合是可迭代对象

练习:
   经理有: 曹操, 刘备, 孙权
   技术员有: 曹操, 孙权, 张飞, 关羽
   用集合求:
     1. 即是经理也是技术员的有谁?
     2. 是经理,但不是技术人员的都有谁?
     3. 是技术人员,但不是经理的人都有谁?
     4. 张飞是经理吗?
     5. 身兼一职的人都有谁?
     6. 经理和技术人员共有几个人?

# 练习:
#   经理有: 曹操, 刘备, 孙权
#   技术员有: 曹操, 孙权, 张飞, 关羽
#   用集合求:
#     1. 即是经理也是技术员的有谁?
#     2. 是经理,但不是技术人员的都有谁?
#     3. 是技术人员,但不是经理的人都有谁?
#     4. 张飞是经理吗?
#     5. 身兼一职的人都有谁?
#     6. 经理和技术人员共有几个人?


manager = {"曹操", "刘备", "孙权"}
techs = {"曹操", "孙权", "张飞", "关羽"}
print("即是经理也是技术员的有:", manager & techs)
print("是经理,但不是技术人员的都有:", manager - techs)
print("是技术人员,但不是经理的人都有", techs - manager)
if "张飞" in manager:
    print("张飞是经理")
else:
    print("张飞不是经理")

print("身兼一职的人都有:", manager ^ techs)
print("经理和技术人员共有", len(manager | techs), "个人")

集合的方法:
   文档参见:
     python_base_docs_html/set.html
  
集合是可迭代对象

集合推导式:
   集合推导式是用可迭代对象创建集合的表达式
   语法:
     { 表达式 for 变量 in 可迭代对象 [if 真值表达式]}
   示例:
     s = { x**2 for x in range(1, 10)}
   集合推导式可以嵌套
     语法同列表推导式的嵌套相同

固定集合 frozenset
   固定集合是不可变的,无序的,含有唯一元组的集合
  
   作用:
     固定集合可以作为字典的键,还可以作为集合的值

  创建固定集合构造函数 frozenset
     frozenset()   创建一个空的固定集合对象
     frozenset(iterable) 用可迭代对象创建一个新的固定集合对象
  示例:
     fz = frozenset() 
     fz = frozenset(range(10))
     fz = frozenset([1, 3, 8, 6, 9])
     d = {frozenset({1,2,3}): "集合1,2,3"}

  固定集合的运算:
     & 交集
     | 并集
     - 补集
     ^ 对称补集
     < 子集
     > 超集
     <= >= == !=
     in / not in
     (以上运算规则等同于set中的规则)

固定集合的方法:
   相当于集合的全部方法去掉修改集合的方法

阶段总结:
   数据类型:
     不可变类型
       数字: bool, int, float, complex
       容器: str, tuple, frozenset, bytes(后面才学)
     可变类型
       list, dict, set, bytearray(后面才学)
   值:
     None, False, True

  表达式:
     1
     1 + 2
     print("hello")
     max("ABC") + min("123")
     条件表达式: x if x > y else y
     全部的推导式: 列表, 字典, 集合推导式

  语句:
     表达式语句:
        print("hello")
        """ABCD"""
     赋值语句:
      a = 100
       a = b = c = 200
       x, y = 100, 200
       L[1] = 200
       d['key'] = '键'
     del语句
     if 语句
     while 语句
     for 语句
     break 语句
     continue 语句
     pass 语句

内建函数:
   容器相关:
     len(x), max(x), min(x), sum(x), any(x), all(x)
   构造函数:
     bool(x)
     int(x)
     float(x)
     complex(r=0.0, i=0.0)
     str(x)
     list(x)
     tuple(x)
     dict(x)
     set(x)
     frozenset(x)
   数值型 函数:
     abs(x)
     round(x)
     pow(x, y, z=None)
   字符串相关
     bin(x)
     oct(x)
     hex(x)
     chr(x)
     ord(x)
   可迭代对象相关:
     range(start, stop, step)
     reversed(x)
     sorted(x, reverse=False)
   输入输出相关:
     input(x)
     print(...)
   其它:
     type(x)
     id(x)
    
  
函数 function
   什么是函数:
     函数是可以重复执行的语句块,可以重复使用
     函数是面向过程编程的最小单位

  函数的作用:
     1. 用于封装语句块,提高代码的重用性
     2. 定义用户级别的函数

def 语句
   语法:
     def 函数名(形参列表):
         语句块(代码块)
   说明:
     1. 函数的名字就是语句块的名称
     2. 函数名的命名规则与变量名相同(函数名必须为标识符)
     3. 函数名是一个变量(不要轻易对其赋值)
     4. 函数有自己的名字空间,在函数外部不可以访问函数内部的变量
        在函数内部可以访问函数外部的变量,要让函数处理外部数据
        需要传入一些数据
     5. 函数如果不需要传入参数,则参数列表可以为空
     6. 语句部分不能为空,如果为空需要填充pass语句
   作用:
     用于创建函数,用函数名这个变量绑定这个函数
   示例见:
     def.py
     def2.py

# def.py


# 此示例示意用def语句定义一个没有参数的函数

def say_hello():
    print("hello world!")
    print("hello china!")
    print("hello tarena!")

say_hello()
say_hello()
say_hello()

# def2.py


# 此示例示意用def语句来定义带有参数的函数
# 此函数名为mymax, 有两个形式参数a, b 用于接收实参的传递
# 此函数计算两个参数的最大值并打印
def mymax(a, b):
    print('a=', a)
    print('b=', b)
    if a > b:
        print(a, "大于", b)
    else:
        print(a, '小于等于', b)

mymax(100, 200)  # 函数调用

函数的调用表达式:
   函数名(实际调用传递参数)

  说明:
     函数调用是一个表达式
     如果没有return语句,函数执行完毕后返回None对象
  
    
练习:
   写一个函数myadd,此函数中的参数列表里有两个参数x,y
   此函数的功能是打印 x + y 的和
   如:
     def myadd(...):
         ...  # ...部分自己实现
     myadd(100, 200)   # 打印 300
     myadd("ABC", "123")  # 打印 ABC123

# 练习:
#   写一个函数myadd,此函数中的参数列表里有两个参数x,y
#   此函数的功能是打印 x + y 的和
#   如:
#     def myadd(...):
#         ...  # ...部分自己实现
#     myadd(100, 200)   # 打印 300
#     myadd("ABC", "123")  # 打印 ABC123


def myadd(x, y):
    z = x + y
    print('和是:', z)

myadd(100, 200)   # 打印 300
myadd("ABC", "123")  # 打印 ABC123

# print(z)  # 报错!
# print(x)
# print(y)

def myadd(x, y):
    z = x + y
    print('和是:', z)

v = myadd(100, 200)   # 打印 300
print("v=", v)   # v= None

#   2. 写一个函数myadd,实现给出两个数,返回这两个数的和
#     如:
#       def myadd(x, y):
#           ...
#       a = int(input("请输入第一个数: "))
#       b = int(input("请输入第二个数: "))
#       print("您输入的两个数的和是:", myadd(a, b))

# 方法1
# def myadd(x, y):
#     z = x + y
#     return z

# 方法2
# def myadd(x, y):
#     return x + y

a = int(input("请输入第一个数: "))
b = int(input("请输入第二个数: "))
print("您输入的两个数的和是:", myadd(a, b))

练习2
   写一个函数print_event,传入一个参数n代表终止的整数,打印
     0 ~ n 之间所有的偶数
   如:
     def print_even(n):
         ..... 此处自己完成
     print_even(10)
   打印:
     0
     2
     4
     6
     8

# 练习2
#   写一个函数print_even,传入一个参数n代表终止的整数,打印
#     0 ~ n 之间所有的偶数
#   如:
#     def print_even(n):
#         ..... 此处自己完成
#     print_even(10)
#   打印:
#     0
#     2
#     4
#     6
#     8


def print_even(n):
    for x in range(0, n+1, 2):
        print(x)

print_even(10)

return 语句:
   语法:
     return [表达式]
     注: [] 代表其中的内容可省略

  作用:
     用于函数中,结束当前函数的执行,返回到调用该函数的地方,同
     时返回一个对象的引用关系

  说明:
     1. return 语句先执行右侧的表达式,再将表达式的执行结果送
        回给当前函数的调用者
     2. return 语句右侧的表达式可以省略,省略后相当
        于return None
     3. 如果函数内没有return语句,则函数执行完最后一条语句后
        返回None(相当于在最后加了一条return None语句)

  示例见:
     return.py

# return.py

# 此示例示意return语句在函数中的应用

def say_hello2():
    print("hello aaa")
    print("hello bbb")
    return  # 等同于 return None
    # return 1 + 2
    # return [1, 2, 3, 4]
    print("hello ccc")

v = say_hello2()
print("v=", v)

v2 = say_hello2()
print("v2=", v2)

# return.py

# 此示例示意return语句在函数中的应用

def say_hello2():
    print("hello aaa")
    print("hello bbb")
    print("hello ccc")
    return None

v = say_hello2()
print("v=", v)

练习:
   1. 写一个函数mymax, 实现返回两个数的最大值:
     如:
       def mymax(a, b):
           .... # 此处自己实现

      print(mymax(100, 200))  # 200
       print(mymax("ABC", 'ABCD'))  # ABCD

# 练习:
#   1. 写一个函数mymax, 实现返回两个数的最大值:
#     如:
#       def mymax(a, b):
#           .... # 此处自己实现

#       print(mymax(100, 200))  # 200
#       print(mymax("ABC", 'ABCD'))  # ABCD

# 方法1
# def mymax(a, b):
#     zuida = a
#     if b > zuida:
#         zuida = b
#     return zuida

# 方法2
# def mymax(a, b):
#     if a > b:
#         return a
#     else:
#         return b

# 方法3
def mymax(a, b):
    if a > b:
        return a
    return b

print(mymax(100, 200))  # 200
print(mymax("ABC", 'ABCD'))  # ABCD

  2. 写一个函数myadd,实现给出两个数,返回这两个数的和
     如:
       def myadd(x, y):
           ...
       a = int(input("请输入第一个数: "))
       b = int(input("请输入第二个数: "))
       print("您输入的两个数的和是:", myadd(a, b))

3 写一个函数 input_number
     def input_number():
         ....  # 此处自己实现,此函数返回列表

    此函数用来获取用户循环输往返整数,当用户输入负数时结束输入
     将用户输入的数字以列表的形式返回,再用内建函数max,min,
     sum 求出用户输入的最大值,最小值及和

    L = input_number()
     print("用户输入的最大数是:", max(L))
     print("用户输入的最小数是:", min(L))
     print("用户输入的全部数的和是:", sum(L))

#  3 写一个函数 input_number
#     def input_number():
#         ....  # 此处自己实现,此函数返回列表

#     此函数用来获取用户循环输往返整数,当用户输入负数时结束输入
#     将用户输入的数字以列表的形式返回,再用内建函数max,min,
#     sum 求出用户输入的最大值,最小值及和

#     L = input_number()
#     print("用户输入的最大数是:", max(L))
#     print("用户输入的最小数是:", min(L))
#     print("用户输入的全部数的和是:", sum(L))




def input_number():
    # 1. 创建空列表
    myL = []
    # 2. 循环读取用户输入的正整数,存入在述列表
    while True:
        x = int(input("请输入正整数: "))
        if x < 0:
            break
        myL.append(x)
    # 3. 返回上述列表的引用关系
    return myL

L = input_number()
print("用户输入的最大数是:", max(L))
print("用户输入的最小数是:", min(L))
print("用户输入的全部数的和是:", sum(L))

练习:
   1. 定义两个函数:
     sum3(a, b, c)  用于返回三个数的和
     pow3(x)        用于返回x的三次方(立方)
     用以上函数计算:
       1. 计算1的立方 + 2的立方+3的立方的和
       2. 计算 1+2+3 的和的立方
       即:
         1**3 + 2**3 + 3**3 和 (1+2+3)**3

#   1. 定义两个函数:
#     sum3(a, b, c)  用于返回三个数的和
#     pow3(x)        用于返回x的三次方(立方)
#     用以上函数计算:
#       1. 计算1的立方 + 2的立方+3的立方的和
#       2. 计算 1+2+3 的和的立方
#       即:
#         1**3 + 2**3 + 3**3 和 (1+2+3)**3


def sum3(a, b, c):  # 用于返回三个数的和
    return a + b + c

def pow3(x):  # 用于返回x的三次方(立方)
    return x ** 3


# 1. 计算1的立方 + 2的立方+3的立方的和
print(sum3(pow3(1), pow3(2), pow3(3)))  # 36

# 2. 计算 1+2+3 的和的立方
print(pow3(sum3(1, 2, 3)))  # 216

  2. 写一个函数 get_chinese_char_count(s), 此函数功能是
     给定一个字符串s,返回这个字符串中中文字符的个数
         def get_chinese_char_count(s):
             ...
         s = input("请输入中英文混合的字符串: ")
         print("中文字符的个数是:",
             get_chinese_char_count(s))
     注: 中文的编码范围是: 0x4E00~0x9FA5

#   2. 写一个函数 get_chinese_char_count(s), 此函数功能是
#     给定一个字符串s,返回这个字符串中中文字符的个数
#         def get_chinese_char_count(s):
#             ...
#         s = input("请输入中英文混合的字符串: ")
#         print("中文字符的个数是:",
#             get_chinese_char_count(s))
#     注: 中文的编码范围是: 0x4E00~0x9FA5


def get_chinese_char_count(s):
    count = 0
    for ch in s:
        if 0x4e00 <= ord(ch) <= 0x9fa5:
            count += 1
    return count

s = input("请输入中英文混合的字符串: ")
print("中文字符的个数是:", get_chinese_char_count(s))

  3. 改写之前的学生信息管理程序:
     用两个函数来封装功能的代码块
        函数1:  input_student()   # 返回学生信息字典的列表
        函数2:  output_student(L)  # 打印学生信息的表格
    
     def input_student():
         ... 此处自己实现
     def output_student(L):
         ... 此处自己实现

    infos = input_student()
     print(infos)  # 打印列表[{...}, {...}]
     output_student(infos)   # 根据实参infos打印表格
    

#   3. 改写之前的学生信息管理程序:
#     用两个函数来封装功能的代码块
#        函数1:  input_student()   # 返回学生信息字典的列表
#        函数2:  output_student(L)  # 打印学生信息的表格

def input_student():
    L = []  # 创建一个列表,准备存放学生数据的字典
    while True:
        n = input("请输入姓名: ")
        if not n:  # 如果用户输入空字符串就结束输入
            break
        a = int(input("请输入年龄: "))
        s = int(input("请输入成绩: "))
        d = {}  # 一定要每次都创建一个新的字典
        d['name'] = n
        d['age'] = a
        d['score'] = s
        L.append(d)   # 把d加入列表中L
    return L

def output_student(L):
    print("+---------------+----------+----------+")
    print("|     姓名      |   年龄   |   成绩   |")
    print("+---------------+----------+----------+")
    for d in L:
        name = d['name']
        age = str(d['age'])  # 转为字符串
        score = str(d['score'])  # 转为字符串
        print("|%s|%s|%s|" % (name.center(15),
                            age.center(10),
                            score.center(10)))
    print("+---------------+----------+----------+")


infos = input_student()
print(infos)  # 打印列表[{...}, {...}]
output_student(infos)   # 根据实参infos打印表格