python基础day08笔记

最新推荐文章于 2020-10-29 21:52:03 发布
最新推荐文章于 2020-10-29 21:52:03 发布
阅读量669 收藏 3
点赞数 1
分类专栏： python基础20课时 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42584444/article/details/81057785
版权

2018.7.11
 day07回顾
  元组tuple

  •    元组是不可变的序列容器

  运算：

  •    + * += *=
  •    < <= > >= == !=
  •    in ,not in
  •    索引和切片


  字典dict

  •    键.值（key-value）对

   键不能重复，且只能用不可变类型做为字典的键
   字典键[键]=值 #添加和修改键-值对

  •    del字典[键]

   {1：100,2:200}
  字典的运算

  •    键索引
  •    字典[键] = value
  •    var = 字典[键]
  •    in，not in



   字典推导式

  •     {键表达式：值表达式 for in 可迭代对象 if 真值表达式...}


day08笔记


    集合 set

  •      集合是可变的容器
  •      集合内的数据对象都是唯一的（不能重复多次）
  •      集合是无序的存储结构，集合中的数据没有先后关系
  •      集合内的元素必须是不可变对象
  •      集合是可迭代对象
  •      集合相当于只有键没有值的字典（键则是集合的数据）


     创建空集合

  •      s = set()

     创建非空集合(不能放单一列表，如列表，字典和集合，可以放迭代对象)
      s = {1,2,3}
      s = {3.14,True,(1970,1,1),'hello'}

      集合的构造函数 set

  •        set() 创建一个空的集合对象（不能用{} 创建空集合）
  •        set(iterable) 用可迭代对象创建一个新的集合对象

      示例：

  •        s = {1,3,5,7}
  •        s = set('abc')
  •        s = set('abccba')
  •        s = set({1:'1',2:'2',5:'5'})
  •        s = set([1,0,3.14,'hello'])
  •        s = set(('abc','123',True))



      集合的运算：

  • 交集，并集，补集，子集，超集


      & 生成俩个集合的交集

  •        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所有元素的集合
  •        s3 = {1}
  •        s4 = s2 - s1
  •        s4 = {4}

      ^生成俩个集合的对称补集 

  •        s1 = {1,2,3}
  •        s2 = {2,3,4}
  •        s3 = s1 ^ s2  #(s1 - s2) |  s2 - s1
  •        s3 = {1,4}

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


       in ,not in 运算符

  •         等同于字典in ，not in

作于集合中，判断某个值是否存在于集合中
     
      集合字典的优点：

  •       in / not in 运算符的判断速度快些


      能用于集合的函数：
 

  •       len(x),max(x),min(x),sum(x),any(x),all(x)


集合练习：
 经理有：曹操，刘备，孙权
 技术员有：曹操，孙权，张飞，关羽
 用集合求：
  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('经理和技术员共有%d个人' % len(manager | techs))



 Python3 集合的方法


方法                   意义

  • S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加
  • S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
  • S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;
  • S.clear() 清空集合内的所有元素
  • S.copy() 将集合进行一次浅拷贝
  • S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
  • S.update(s2) 用 S与s2得到的全集更新变量S
  • S.difference(s2) 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
  • S.difference_update(s2) 等同于 S = S - s2
  • S.intersection(s2) 等同于 S & s2
  • S.intersection_update(s2) 等同于S = S & s2
  • S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False
  • S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False
  • S.issuperset(...) 如果S为s2的子集返回True,否则返回False
  • S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2
  • S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 S
  • S.union(s2) 生成 S 与 s2的全集


集合推导式
 集合推导式是用可迭代对象生成集合的表达式


 语法：
  {表达式 for 变量 in 可迭代对象 [if 真值表达式]}

  注：[] 括号部分可省略
示例：

  •  l = [1,3,5,7,2,4,6,8,1,3,5]
  •  s = {x for x in l}  #{1, 2, 3, 4, 5, 6, 7, 8}


 集合推导式可以嵌套：
   语法同列表推导式一致

 练习：
  任意输入一些数字，存于列表L中，当输入负数时结束输入
  1）打印这些数的和
  2）打印这些数有多少种（去重）
  3）除重复的数字后，打印这些剩余数字的和
  
  提示可以用集合去重
 

L=[]
while True:
    n = int(input('任意输入一些数字'))
    if n < 0:
        break
    L+=[n]
print(L)
print('和',sum(L))
s = set(L)
print('种',len(s))
print('和',sum(s))


 固定集合 frozenset

  •  固定集合是不可变的，无序的，含有唯一元素的集合

  作用：

  •    固定集合可以作为字典的键，还可以作为集合的值


 固定集合的构造函数：
  frozenset() 创建一个空的固定集合
  frozenset(iterable) 用可迭代对象创建固定集合


 示例：

  •   f = frozenset()   #空固定集合
  •   f = frozenset([1,3,5,7]) #f = frozenset({1,3,5,7})



  固定集合的运算：

  •    &交集，|并集，-补集，^对称补集
  •    < <= > >= == !=
  •    in ,not in

   （以上运算符和集合set中的用法一致）

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


 总结
 1,数据类型：
  数值类型：

  •    int，float，complex，bool

  容器：
   不可变的容器

  •    str，tuple，frozenset，bytes（字节串）


   可变的容器

  •    list，dict，set，bytearray（字节数组）


 2,值：

  •    None，False，True



 3,运算符
  算数运算符

  •    + - * / // % **

   比较运算符

  •    < <= > >= == !=

 

  •    in / not in
  •    is ,is not

  布尔运算：

  •    not，and，or
  •    +（正号）-（负号）
  •    & ^ |
  •    [] (索引，切片，键索引)


   表达式：

  •    1
  •    1+2
  •    max（1,2,3） #函数调用是表达式
  •    x if x > y else y,  条件表达式

   三种推导式：

  •     列表，字典，集合，推导式（三种）

  语句
   表达式语句：
    所有的表达式都可以单独写在一行，形成一个语句，例:

  •    print('hello world')
  •    1+2

   赋值语句：

  •     a = 100
  •     a = b = c = 100
  •     x,y = 100,200
  •     a[0] = 100
  •     dict['name'] = 'tarena'
  1.     del 语句
  2.     if 语句
  3.     while语句
  4.     for 语句
  5.     break语句
  6.     continue语句
  7.     pass语句


   内建函数：

  •     len(x),max(x),min(x),sum(x),any(x),all(x)

   构造函数(用来创建同类型的数据对象)

  •     bool(x),int(x),float(x),complex(x),list(x)
  •     tuple(x),str(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(strat,stop,step)
  •     input(x),print(x)
  • >>>help(__builtins__)

 
  函数 function
   什么是函数：

  •     函数是可以重复执行的语句块，可以重复调用

   作用：

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

   语法：

  •     def 函数名(形参列表)：
  •         语句块

   说明：

  1. 函数的名字就是语句块的名称
  2. 函数名的命名规则写变量名相同（函数名必须是标识符）
  3. 函数名是一个变量（不要轻易对其赋值）
  4. 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数可以访问函数外部的变量，但不能修改此变量
  5. .函数如果不需要传入参数，形参列表可以为空
  6. 语句部分不能为空，如果为空需要填充pass

    示例见：

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


say_hello()  # 调用函数
say_hello()
say_hello()

函数调用
     函数名（实际调用传递参数）
      注：实际调用传递参数，以后简称实参


   说明：

  1. 函数调用是一个表达式
  2. 如果函数内部没有return语句，函数调用完毕后返回None对象
  3. 如果函数需要返回其它的对象要用到 return 语句



 写一个函数，打印出给定俩个数的最大值

def mymax(a, b):
    print('a =', a)
    print('b =', b)
    if a > b:
        print(a, "最大")
    else:
        print(b, '最大')


mymax(100, 200)
mymax("ABC", "123")


练习：
 1，写一个函数myadd，此函数中的参数列表里有两个参数x，y
  此函数的功能是打印x + y的和

def myadd(x, y):
    print(x + y)


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


 2，写一个函数mysum，传入一个参数x代表终止整数，打印出
 1+2+3+4+5++++x的和？

方法一：
def mysum(x):
    a = 0
    i = 1
    while i <= x:
        # print(i,end='')
        a += i
        i += 1
    print('和',a)
mysum(100)
mysum(4)
方法二：
def mysum(x):
    s = 0
    for n in range(1,x+1):
        #print(n,end = '+')
        s += n
    print(s)
mysum(100)
mysum(4)
方法三：
def mysum(x):
    c = []
    for n in range(1,x+1):
        #print(n,end = '+')
        c+=[n]
    print(sum(c))
mysum(100)
mysum(4)


return 语句
 语法：

  •   return[表达式]

  注：[]代表可省略
 作用：

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

 return 语句说明

  1. return 语句后跟的表达式可以省略，省略后相当于return None
  2. 如果函数内没有return语句，则函数执行完最后一条语句后返回None（相当于在最后加了一条return None语句）

 示例： 

def my():
    print('aaaaaa')
    print('bbbbbb')
    return[1,2,3,4]
    print('cccccc')
v = my()   #aaaaaa
           #bbbbbb
print(v)   #[1, 2, 3, 4]


 练习：
  1.写一个函数 mymax，给函数传递两个参数，返回两个实参中最大的一个
 

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

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

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

v = mymax(100, 200)
print('v =', v)  # v = 200
print(mymax('ABC', 'abc'))  # abc



 2.写一个函数input_rumber 
 def input_rumber():
    ...
  此函数用来获取用户循坏输入的整数，当用户输入负数时结束输入，
  将用户输入的数字以列表的形式返回，再用内建函数max，min，sum
  取出输入最大值，最小值，及和

def input_number():
    # 此处得到键盘输入的整数，最后以列表的形式返回回去
    lst = []
    while True:
        n = int(input("请输入一个大于零的整数: "))
        if n < 0:
            break
        lst.append(n)

    return lst


L = input_number()
print(L)  # 打印此列表
print("用户输入的最大数是:", max(L))
print("用户输入的最小数是:", min(L))
print("用户输入的数的和是:", sum(L))


练习：
 1，写一个函数print_odd，
 打印从begin开始，到end结束内的全部奇数
    
    def print_odd(begin,end):
    ...
    peint_old(1,10) #打印13579
    peint_old(1,10) #打印11 13 15 17 19

# 方法1
def print_odd(a, b=0):
    if b == 0:
        for x in range(1, a, 2):
            print(x, end=' ')
        else:
            print()
    else:
        if a % 2 == 0:  # 如果是偶数，变为奇数
            a += 1
        for x in range(a, b, 2):
            print(x, end=' ')
        else:
            print()

def print_odd(a, b=None):
    if b is None:
        start = 1
        end = a
    else:
        start = a
        end = b
    # 如果开始的偶数，做校正
    if start % 2 == 0:
        start += 1
    for x in range(start, end, 2):
        print(x, end=' ')
    print()


print_odd(10)  # 1 3 5 7 9
print_odd(11, 20)  # 11 13 15 17 19     
print_odd(10, 20)
print_odd(5, 0)


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

def sum3(a, b, c):
    return a + b + c


def pow3(x):
    return x ** 3


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

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




 3，改写之前的学生信息管理程序改为俩个函数：
   1.写一个函数input_student()
  用于返回学生信息的字典的列表（以前格式一样）
   2.写一个函数output_student(lst)
    此函数传入一个列表lst，即字典的列表
    此函数把lst的内容以表格形式打印出来
   def input_student():
     ...
   def output_student():
     ...


   L = input_student()  #获取学生信息的列表
   output_student(L)    #把L以列表的形式打印

def input_student():
    L = []  # 创建一个容器准备放入
    while True:
        name = input('请输入姓名: ')
        if not name:  # 如果名字为空,结束输入操作
            break
        age = int(input("请输入年龄: "))
        score = int(input("请输入成绩: "))
        d = {}  # 每次都会执行{} 来创建新的字典
        d['name'] = name
        d['age'] = age
        d['score'] = score
        L.append(d)
    return L


def output_student(lst):
    # 打印表格
    print("+---------------+----------+----------+")
    print("|     name      |   age    |   score  |")
    print("+---------------+----------+----------+")
    for d in lst:
        n = d['name'].center(15)
        a = str(d['age']).center(10)
        s = str(d['score']).center(10)
        print("|%s|%s|%s|" % (n, a, s))

    # print("|   xiaozhang   |    20    |   100    |")
    # print("|     xiaoli    |    18    |    98    |")
    print("+---------------+----------+----------+")


L = input_student()  # 获取学生信息的列表
# print(L)
output_student(L)  # 把L 以列表的形式打印

 

CSDN时光
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
python_day08(笔记及练习)
ZYP_PYTHON的博客
01-09 206
函数参数 实参传递方式argument """ 函数参数 实际参数：调用者以何种方式传递数据 位置实参 -- 序列实参 关键字实参 -- 字典实参 """ def func01(p1, p2, p3): print(p1) print(p2) ...
Python学习笔记Day07--Day08
weixin_44823151的博客
07-20 156
Day07Time库的使用 import time ‘’‘scale=10 print("------start------") for i in range(scale+1): a=’*‘i b=’.’(scale-i) c=(i/scale)*100 print("{:^3.0f}%[{}->{}]".format(c,a,b)) time.sleep(1.0)#进度条动态每隔1秒再执行...
Python笔记day08（基础）|文件操作、编码方式
拼搏的小白
08-13 173
Python笔记day08（基础） 1，文件操作。 模特主妇护士老师.txt 1,文件路径：d:\模特主妇护士老师.txt 2,编码方式：utf-8 gbk 。。。。 3，操作方式：只读，只写，追加，读写，写读….. 以什么编码方式储存的文件，就以什么编码打开进行操作。 只读：r rb f = open('模特主妇护士班主任',mode=...
Python基础day07-08学习笔记回顾
凋落的枫叶
09-02 166
 
刻意练习Python基础——day 08：字典与集合
KevinDurantFly的博客
10-27 166
1.字典 字典是另一种可变容器模型，且可存储任意类型对象 创建：用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 d={'Michael':95,'Bob':75,'Tracy':85} 可以用 del 来删除字典一个键值对 dict() 构造函数可以直接从键值对序列里创建字典 2.集合 集合可以包含一组元素，与字典类似，也是使用{}来表示 不同的是，字典储存的是...
python基础day01.txt
04-27
python 基础 python3 (CPython) python文件名通常以 .py结尾 # 方法1 $ python3 xxxx.py # 方法2 $ chmod +x xxxx.py # 修改 xxxx.py 第一行 #! /usr/bin/python3 $ ./xxxx.py 交互模式: $ python3 >>> ...
【Python基础学习笔记】Day·1
01-20
python的注释分两种： 1·单行注释：使用 # 号对文本进行注释 例：print(Hello World) #打印字符串Hello World 2·多行注释：使用 ‘’’ ‘’’ 一对三引号对文本进行注释 例：''' Python是一种跨平台的...
Python学习笔记 day4 基础4
12-21
Python学习笔记——基础4 在Python编程中，掌握基础语法和高级特性是非常重要的。这篇学习笔记将探讨四个关键概念：列表生成式、迭代器与生成器、装饰器以及数据序列化，这些都是Python编程中常用且实用的技术。 1...
python笔记DAY4.docx
10-05
在Python笔记DAY4中，我们重点探讨了函数的基础知识，包括函数的定义、调用、参数类型以及返回值。 首先，函数的定义使用关键字`def`，后跟函数名和圆括号内的参数列表。调用函数时，我们只需提供函数名和所需的...
python笔记DAY1.docx
09-23
在Python编程语言的学习中，第一天的笔记主要涵盖了基础概念，包括打印输出、文件路径操作、文件创建、程序运行方式以及变量、运算符等基础知识。以下是对这些知识点的详细阐述： 1. **打印输出**： 在Python中，...
python3 基础 练习 源码 2
pythondafahao的博客
02-07 901
#     2. 定义两个函数: #    sum3(a, b, c)  用于返回三个数的和 #    pow3(x)        用于返回x的三次方 #   1)　计算 1 的立方 + 2的立方 + 3的立方的和 #     即：　1**3 + 2**3 + 3**3 #   2) 计算 1 + 2 + 3 的和的立方 #   　　即: (1+2+3) ** 3
Python基础-08
骨敢的博客
06-24 325
day07回顾:  序列列表:  in / not in  id(x)  / is 运算符是用id来判断  不要把 is 当成 == 来用  a is None  # 用来判断 a 是否绑定None对象  a = 10000  a = None  # 减少对10000这个对象的引用计数问题:  a = 10000  b = 10000  print(a is b)  # 结果不一定列表的索引赋值和...
Python全栈工程师（集合、函数）
ParisGabriel
07-11 291
         ParisGabriel    　　　　　　　　　　　　　 感谢 大家的支持  你们的阅读评价就是我最好的动力  我会坚持把排版内容以及偶尔的错误做的越来越好    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    　　　　　　　　　　　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　每天坚持 一天一篇 点个订阅吧  灰常感谢   ...
Python学习记——（8）集合、函数
糖糖的小窝
07-24 328
集合 set   集合是可变的容器   集合内的数据对象都是唯一的（不能重复多次的)   集合是无序的存储结构，集合中的数据没有先后顺序关系   集合内的元素必须是不可变的对象   集合是可迭代对象   集合是相当于只有键没有值的字典（键则是集合的数据） 创建空的集合: set() 创建非空集合: s = {1, 2, 3} 集合的构造(创建)函数 set   set()  创...
python input输入的内容是什么类型-Python input()函数：获取用户输入的字符串
weixin_37988176的博客
10-29 9140
input() 是 Python 的内置函数，用于从控制台读取用户输入的内容。input() 函数总是以字符串的形式来处理用户输入的内容，所以用户输入的内容可以包含任何字符。input() 函数的用法为：str = input(tipmsg)说明：str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样...
Python学习记——（9）函数
糖糖的小窝
07-25 689
问题:     def mysum(a, b):         print(a + b)        r = mysum(100, 200)     print(r)  # 请问r绑定的是什么？   # 让mysum返回一个加法的结果:     def mysum(a, b):         result = a + b     r = mysum(100, 200)   ...
python语言篇（6练习1）
Jason_Edison的博客
03-21 572
# 1. 算出 100 ~ 999 以内的水仙花数(Narcissistic Number) # 水仙花数是指百位的3次方 加上 十位的3次方 加上个位的3次方等于原数的数字 # 例如: # 153 等于 1**3 + 5**3 + 3**3 # 方法1 # for x in range(100, 1000): # gewei = x % 10 # 求个位 ...
python day09 函数 function
随芯的博客
06-25 356
目录： 函数 function 什么是函数: 函数的语法说明： 示例1: 函数调用: python函数的参数传递 #### 以下讲函数的形参 函数的缺省参数 函数的形参定义方式: 函数 function 什么是函数: 定义：函数是可以重复执行的语句块，可以重复调用。 作用： 用于封装可重复执行的语句，提高语句的可重用性 定义用户级别的函数 ...
day08集合2固定集合3函数
weixin_44119390的博客
06-19 1093
day07回顾 元组 tuple 可以是任意类型的数据(类似于列表) 元组是不可变的序列(类似于字符串) () (20,) (10, 20) 20, 10, 20 构造函数tuple() / tuple(可迭代对象) 字符串, 列表,元组的运算: + += * *= < <= > >= == != in / not in 索引 ind...
python海龟笔记
最新发布
09-06
- *1* [Python基础学习简记--海龟绘图（Day10）](https://blog.csdn.net/weixin_39344224/article/details/102807350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值