精华内容
下载资源
问答
  • Python知识点总结大全(一) 万次阅读 多人点赞
    2019-12-18 18:03:45

    python逻辑运算符

    1.成员

    and or not

    优先级:() > not > and > or

    2.and

    逻辑运算符and,a andb,如果a和b都为True,则返回True,如果其中一个为False,返回False,简言之:一假则假,全真则真

    3.or

    逻辑运算符or,a or b, 如果a和b有一个为True,则返回True,如果全为False,返回False,简言之:一真则真,全假则假

    4.not

    逻辑运算符not,是结果的相反逻辑,比如 not 4>5为True

    5.优先级级别从上至下

    运算符描述
    **指数 (最高优先级)
    ~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
    * / % //乘,除,取模和取整除
    + -加法减法
    >> ,<<右移,左移运算符
    &位 ‘AND’
    ^|位运算符
    <= < > >=比较运算符
    <> == !=等于运算符
    = %= /= //= -= += *= **=赋值运算符
    is, is not身份运算符
    in, not in成员运算符
    Not , and, or逻辑运算符

    python中list列表和字典的区别与联系

    Python的基础数据结构有:列表(list), 元祖(tuple), 字典(dict), 字符串(string), 集合(set)等,区别联系如下:

    数据类型列表 (list)元祖 (tuple)集合 (set)字典 (dictionary)
    表示[]()(){}
    举例a_list = [1, True, ‘aa’]a_tuple = (1, True, ‘aa’); t2 = (1,)a_set = {1, True, ‘aa’}; s = set( [1, True, ‘aa’])a_dict = {‘name’: ‘xuan’, ‘age’: 21}
    是否有序有序有序无序无序
    是否读写读写只读读写读写读写
    空定义a_list = []a_tuple = ()a_set = set(); not_sure = {}空字典a_dict = {}
    元素可修改a_list[0] = 23a_dict[‘age’] = 30
    下标访问a_list[0] = 23a_tuple[0]a_dict[‘age’] = 30
    添加元素+、append、extend、insert不可添加add、updatea_dict[‘new_key’] = ‘value’
    删除元素del、remove、pop()、pop(1)、clear不可删除discard、remove、pop、clearpop、popitem、clear
    元素查找index、count、ininina_dict[‘key’]
    布尔真值非空非空非空非空
    定义列表(list)是有序的集合,可以存放不同数据类型的数据,并且list中的每个元素的都对应着一个索引来标记其位置,且索引从0开始。tuple与list类似,不同之处在于tuple中的元素不能进行修改。而且tuple使用小括号,list使用方括号。set()函数是创建一个无序不重复元素集,可添加,删除数据,还可以计算交集、差集、并集等。 python 的集合类型和 其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.集合对象还支持union(联合), intersection(交), difference(差)和sysmmetricdifference(对称差集)等数学运算,和我们初中数学学的集合的非常的相似。dic字典是另一种可变的容器模型,且可存储任意类型对象。字典的每个键值(key:value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号{}中

    列表list -元祖-tuple- 集合set-字典dic全方位分析

    数据结构表示分析
    列表list[]列表list,用中括号“[ ]”表示 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现 3.可变长度,异构以及任意嵌套 列表中的元素可以是任意类型,甚至是列表类型,也就是说列表可以嵌套 4.可变的序列 支持索引、切片、合并、删除等等操作,它们都是在原处进行修改列表 5.对象引用数组 列表可以当成普通的数组,每当用到引用时,Python总是会将这个引用指向一个对象,所以程序只需处理对象的操作。当把一个对象赋给一个数据结构元素或变量名时,Python总是会存储对象的引用,而不是对象的一个拷贝
    元祖tuple()1.任意对象的有序集合 与列表相同 2.通过偏移存取 与列表相同 3.属于不可变序列类型 类似于字符串,但元组是不可变的,不支持在列表中任何原处修改操作,不支持任何方法调用 4.固定长度、异构、任意嵌套 固定长度即元组不可变,在不被拷贝的情况下长度固定,其他同列表 5.对象引用的数组 与列表相似,元祖是对象引用的数组> tuple和list相比 1.比列表操作速度快 2.对数据“写保护“ 3.可用于字符串格式化中 4.可作为字典的key
    字典dic{}1.通过键而不是偏移量来读取 字典就是一个关联数组,是一个通过关键字索引的对象的集合,使用键-值(key-value)进行存储,查找速度快 2.任意对象的无序集合 字典中的项没有特定顺序,以“键”为象征 ** 3.可变长、异构、任意嵌套** 同列表,嵌套可以包含列表和其他的字典等 4.属于可变映射类型 因为是无序,故不能进行序列操作,但可以在远处修改,通过键映射到值。字典是唯一内置的映射类型(键映射到值的对象) 5.对象引用表 字典存储的是对象引用,不是拷贝,和列表一样。字典的key是不能变的,list不能作为key,字符串、元祖、整数等都可以 dic和list比较,dict有以下几个特点: 1.查找和插入的速度极快,不会随着key的增加而增加 2.需要占用大量的内存,内存浪费多 而list相反: 1.查找和插入的时间随着元素的增加而增加 2.占用空间小,浪费内存很少 所以,dict是用空间来换取时间的一种方法
    集合()1.是一组key的集合,但不存储value,并且key不能重复 创建一个set,需要提供一个list作为输入集合,s = set([1,2,3]),注意,传入的参数 [1, 2, 3] 是一个list,而显示的 set([1, 2, 3]) 只是告诉你这个set内部有1,2,3这3个元素,显示的[ ]不表示这是一个list 2.重复元素在set中自动被过滤 set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作 还有一种集合是forzenset( ),是冻结的集合,它是不可变的,存在哈希值,好处是它可以作为字典的key,也可以作为其它集合的元素。缺点是一旦创建便不能更改,没有add,remove方法 set和dict对比 1.set和dict的唯一区别仅在于没有存储对应的value 2.set的原理和dict一样,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”

    字典-列表-集合-元祖相互比较

    比较详情
    字典dict和列表list的比较dict的查找和插入的速度极快,不会随着key的增加而变慢。但是需要占用大量的内存,内存浪费多。相反,list查找和插入的时间随着元素的增加而增加。但是占用空间小,浪费内存很少。
    字典dict和集合set比较唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。
    元祖tuple与列表list比较tuple与list类似,不同之处在于tuple中的元素不能进行修改。而且tuple使用小括号,list使用方括号。

    Python一些内置函数

    编号函数注释
    1cmp(A, B)比较可为list、tuple等的A、B,A>B为1,A=B为0,小于为-1
    2len(obj)计算元素个数。
    3max(obj)返回元素最大值。
    4min(obj)返回元素最小值。
    5reversed(obj)对元素进行翻转
    6enumerate(obj)遍历list的元素,返回序号及其对应的元素 for x,y in list:
    7zip()打包成tuple(元组),然后返回由这些tuples组成的list(列表)

    列表[]、元组()和字符串都是序列,字符串是字符的序列,列表和元祖是任意类型的序列

    python 中else在while循环中的用法

    else 可以在while和for循环中运用,else和while或for搭配使用,不再是条件判断的含义。而是当while条件不成立时,直接跳出while循环,执行else输出如:

    count = 0
    while count > 12:
       if True:
          print('Yes')
          break
       count += 1
    else:
       print('No')
    
    # 输出
    No
    
    a = 0
    while a < 6:
       print('loop',a)
       a = a + 1
    else:
       print('well done!')#没有break的情况下,循环没有被打断
    
    # 输出
    loop 0
    loop 1
    loop 2
    loop 3
    loop 4
    loop 5
    well done!
    
    a = 0
    while a < 6:
       print('loop', a)
       a += 1
       break # 有break的情况下,执行一次循环中止了,这种情况下不是正常中止的,else代码块是不执行的
    else:
       print('Well done!')
    
    # 输出
    loop 0
    

    总结:else下的代码块在while循环正常执行结束了之后就会执行else代码块。否则,不执行。

    匿名函数

    为了解决那些功能很简单的需求而设计的一句话函数

    语法:lambda 参数列表 : 表达式

    说明:使用lambda关键字创建匿名函数。所谓匿名函数,就是没有名字的函数。匿名函数冒号后面的表达式有且只能有一个,注意:是表达式,而不是语句。匿名函数自带return,而return的结果就是表达式的计算后的结果。

    通过对比匿名函数和普通函数来说明下lambda的用法

    1.无参匿名函数:

    >>>t = lambda : True #分号前无任何参数
    >>>t()
    True
    # 等价于
    >>> def func(): return True
    >>> func()
    True 
    

    2.带参数匿名函数

    >>> lambda x: x**3 #一个参数
    >>> lambda x,y,z:x+y+z #多个参数
    >>> lambda x,y=3: x*y #允许参数存在默认值
    # 匿名函数调用
    >>> c = lambda x,y,z: x*y*z
    >>> c(2,3,4)
    24
    >>> c = lambda x,y=2: x+y #使用了默认值
    >>> c(10) #不输的话,使用默认值2
    12
    >>> a = lambda *z:z  # *z返回的是一个元祖,即返回的是和参数一样的类型
    >>> a('Testing1','Testing2')
    ('Testing1', 'Testing2')
    
    

    3.直接后面传递实参

    >>> (lambda x,y: x if x> y else y)(101,102)
    102
    >>> (lambda x:x**2)(3)
    9
    # lambda返回的值,结合map,filter,reduce使用
    >>> filter(lambda x:x%3==0,[1,2,3,4,5,6])
    [3, 6]
    
    # 等价于下面的列表推导式
    >>> l = [x for x in [1,2,3,4,5,6] if x%3==0]
    >>> l
    [3, 6]
    

    4.嵌套使用

    # lambda嵌套到普通函数中,lambda函数本身做为return的值
    >>> def increment(n):
                 return lambda x: x+n
    >>> f=increment(4)
    >>> f(2)
    6
    
    >>> def say():
    			title = 'Sir,'
    			action= lambda x: title + x
    			return action
    >>> act = say()
    >>> act('Smith!')
    'Sir,Smith!'
    

    5.大量例子

    # 例01:字符串联合,有默认值,也可以x=(lambda...)这种格式
    >>> x = (lambda x="Boo",y="Too",z="Zoo": x+y+z)
    >>> x("Foo")
    'FooTooZoo'
    
    # 例02: 和列表联合使用
    >>> L = [lambda x:x**2,\
    lambda x:x**3,\
    lambda x:x**4]
    
    >>> for f in L:
    ... print f(2)
    ...
    4
    8
    16
    # 也可以如下面这样调用
    >>> print L[0](3)
    9
    
    # 例03: 和字典结合使用
    >>> key = 'B'
    >>> dic = { 'A': lambda: 2*2,\
    ... 'B': lambda: 2*4,\
    ... 'C': lambda: 2*8}
    >>> dic[key]()
    8
    
    # 例04: 求最小值
    >>> lower = lambda x,y: x if x<y else y
    >>> lower('aa','ab')
    'aa'
    
    # 例05: 和map及list联合使用
    >>> import sys
    >>> showall = lambda x:list(map(sys.stdout.write,x))
    >>> showall(['Jerry\n','Sherry\n','Alice\n'])
    Jerry
    Sherry
    Alice
    
    >>> showall(['Jerry','Sherry','Alice'])
    JerrySherryAlice
    
    #等价于下面
    >>> showall = lambda x: [sys.stdout.write(line) for line in x]
    >>> showall(('I\t','Love\t','You!'))
    I Love You![None, None, None]
    
    # 例06: 在Tkinter中定义内联的callback函数
    import sys
    from Tkinter import Button,mainloop
    x = Button(text='Press me',
    command=(lambda:sys.stdout.write('Hello,World\n')))
    x.pack()
    x.mainloop()
    
    >>>
    Hello,World!
    Hello,World!
    
    # 例07: lambda和map联合使用,
    
    >>>  out = lambda *x: sys.stdout.write(' '.join(map(str,x)))
    >>> out('This','is','a','book!\n')
    This is a book!
    
    # 例08: 判断字符串是否以某个字母开头
    >>> print (lambda x: x.startswith('B'))('Bob')
    True
    >>> Names = ['Anne', 'Amy', 'Bob', 'David', 'Carrie', 'Barbara', 'Zach']
    >>> B_Name= filter(lambda x: x.startswith('B'),Names)
    >>> B_Name
    ['Bob', 'Barbara']
    
    # 例09: lambda和map联合使用
    >>>  squares = map(lambda x:x**2,range(5))
    >>> squares
    [0, 1, 4, 9, 16]
    
    # 例10. lambda和map,filter联合使用
    >>>  squares = map(lambda x:x**2,range(10))
    >>> filters = filter(lambda x:x>5 and x<50,squares)
    >>> filters
    [9, 16, 25, 36, 49]
    
    # 例11. lambda和sorted联合使用
    # 按death名单里面,按年龄来排序
    # 匿名函数的值返回给key,进来排序
    >>> death = [ ('James',32),
    ('Alies',20),
    ('Wendy',25)]
    >>> sorted(death,key=lambda age:age[1]) #按照第二个元素,索引为1排序
    [('Alies', 20), ('Wendy', 25), ('James', 32)]
    
    # 例12. lambda和reduce联合使用
    >>> L = [1,2,3,4]
    >>> sum = reduce(lambda x,y:x+y,L)
    >>> sum
    10
    
    # 例13. 求2-50之间的素数
    #素数:只能被1或被自己整除的数
    >>> nums = range(2,50)
    >>> for i in nums:
    nums = filter(lambda x:x==i or x % i,nums)
    >>> nums
    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
    
    # 例14. 求两个列表元素的和
    >>> a = [1,2,3,4]
    >>> b = [5,6,7,8]
    >>> map(lambda x,y:x+y, a,b)
    [6, 8, 10, 12]
    
    #例15. 求字符串每个单词的长度
    >>> sentence = "Welcome To Beijing!"
    >>> words = sentence.split()
    
    >>> lengths = map(lambda x:len(x),words)
    >>> lengths
    [7, 2, 8]
    
    # 写成一行:
    >>>  print map(lambda x:len(x),'Welcome To Beijing!'.split())
    

    函数名的应用、闭包

    函数名可以作为一个变量,函数的参数,函数的返回值,容器类类型的元素

    1.作为一个变量

    def func1():
        print(666)
    
    f1 = func1  # 这里函数名实际上是个变量,只是变量名改了而已
    f2 = f1
    
    >>>
    f2()
    666
    

    2.作为函数的参数

    def func2(x):
        print(x)
        print('===', x())
    
    print(func2(func1))  # 把func1的地址作为func2的参数,再执行func2函数。
    
    >>>
    
    <function func1 at 0x000001898B86FE18>
    666
    === None
    None
    

    3.函数名作为返回值

    def wraaper():
        def inner():
            print('inner  ')
        return inner
    ret = wraaper()
    ret()
    
    >>> 
    
    inner   
    '''
    此时执行了inner()函数,为什么执行外部函数可以执行内嵌的函数呢,因为return了函数名,实际上形成了闭包。
    

    4.闭包
    当return一个嵌入的函数名时,在全局命名空间就可以直接找到该函数的地址,也就是可以执行函数,原理是在全局变量空间外层的函数的内存地址指向了嵌入的函数的内存地址。通常要执行内层的函数时必须执行外层的函数才可以执行内嵌的函数,当外层函数return了内嵌的函数名,实际上把内嵌的函数地址放在外面了,就是告诉所有外部人,这就是我的地址,通过这个地址你们就可以找到我。

    enumerate() 枚举函数

    enumerate(iterable, start =0)

    返回一个枚举对象,第一个参数必须是一个序列,一个迭代器,或者其他支持迭代的对象。用enumetate()利用iterator中next()的方法返回一个包含计数(默认从0)开始的以及从迭代中获得的值元组。

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>>print(tuple(enumerate(seasons)))  
    >>>print(list(enumerate(seasons, start=4)))  # 从4开始数
    
    ((0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter'))
    [(4, 'Spring'), (5, 'Summer'), (6, 'Fall'), (7, 'Winter')]
    

    往期推荐:
    Python知识点大全(一)
    Python知识点大全(二)

    更多相关内容
  • python知识点整理.pdf

    2021-01-06 13:00:19
    python知识点整理.pdf
  • python知识点汇总 思维导图,条理清晰,简单明了,还可以用作笔记查询
  • 总结python知识点大全
  • Python知识点(史上最全)

    万次阅读 多人点赞 2021-07-28 22:40:37
    Python期末考试知识点(史上最全) python简介 Python是一种解释型语言 Python使用缩进对齐组织代码执行,所以没有缩进的代码,都会在载入时自动执行 数据类型:整形 int 无限大 浮点型 float 小数 复数 complex ...

    Python期末考试知识点(史上最全)

    ✅作者简介:大家好我是编程ID
    📃个人主页:编程ID的csdn博客
    系列专栏:python
    💬推荐一款模拟面试、刷题神器👉点击跳转进入网站

    请添加图片描述
    请添加图片描述

    请添加图片描述

    请添加图片描述

    请添加图片描述

    请添加图片描述
    请添加图片描述

    请添加图片描述

    python简介

    Python是一种解释型语言
    Python使用缩进对齐组织代码执行,所以没有缩进的代码,都会在载入时自动执行
    数据类型:整形          int              无限大 
                      浮点型      float            小数
                      复数         complex       由实数和虚数组成
    
    Python中有6个标准的数据类型:
            Number(数字)
            String(字符串)
            List(列表)
            Tuple(元组)
            Sets(集合)
            Dictionart(字典)
    其中不可变得数据:
                   Number(数字)            String(字符串)            Tuple(元组)            Sets(集合)
    可变得:
                   List(列表)         Dictionart(字典)    
    我们可以用type或者isinstance来判断类型
    

    请添加图片描述

    type()不会认为子类是一种父类类型。
    isinstance()会认为子类是一种父类类型

    python中定义变量,不需要写变量类型,但是必须初始化。会根据我们写的数据类型,自动匹配
    变量命名规则:由字母,数字,下划线组成,第一个必须字母或者下划线,对大小写敏感,不能是关键字
    
    输入与输出
        在我们需要输入中文的时候,需要包含头文件  # -*- coding: UTF-8 -*- 或者 #coding=utf-8
        输入    a=input("请输入一个数字")          返回值为str类型
        输出    print('hello world')                        当然这里也可以严格按照格式控制符去输出变量值
            例如:print("now a=%d,b=%d"%(a,b))        双引号后面没有逗号
         print默认换行,我们可以print( end=''),修改默认参数让他不换行,
                                    也可以在print()后面加逗号  print(xxx) ,   这样也可以不换行    测试发现:只适合在2.7版本
    
    1. 基础语法
      运算符:
      算术运算符: 多了一个**,代表 幂方 5**5 就是5的5次方 还多了一个 // 整数除法
      逻辑运算符: and,or,not 与,或,非
      赋值运算符: 没有++,–
      身份运算符: is is not

    成员关系运算符: in not in
    总结:多出来了** 和 // //就是整除的意思 比如 5//3结果为 1 但是5/3结果为小数 1.6666666667

    运算符优先级(下面由高到低):幂运算符最高
    幂运算符                **
    正负号                    + -
    算术运算符            *,/,//,+,-
    比较运算符            <,<=,>,>=,==,!=
    逻辑运算符            not,and,or    (not>and>or)
    

    选择结构
    if-else
    if-elif-else(这里可以不写else)

         逻辑结果
            python里面只要是"空”的东西都是false    ""(中间有空格就为真,这里什么都不写,为假)    空元组,空列表,空字典    0 都为false
    

    字符串
    请添加图片描述

    Pis:在字符串前面添加一个 r,表示原始字符串,不会发生转义
    列表
    list是处理一组有序项目的数据结构,用方括号定义
    列表的操作:
    一,通过下标去访问列表中的值 (可以用切片的方式去访问)

         输出结果:这里就用了切片的方式去访问1到5
          
    重点:这里切片的使用方法要注意,我们写的1:5实际访问的是下标为1,2,3,4.没有5!
    

    请添加图片描述

    二,更新列表(列表是可以修改的)
    通过下标去直接修改他的值

    三,删除列表元素(del + 列表项) 删除项remove()后面说
    请添加图片描述

    四,列表的脚本操作符

    请添加图片描述

    五,对于列表截取,拼接
    请添加图片描述

    六,list自带函数 (其中有元组转列表)

    方法 功能
    max(list) 返回列表元素最大值
    min(list) 返回列表元素最小值
    list(seq) 元组转列表
    list.append(obj) 在列表末尾添加新对象
    list.count(obj) 统计某个元素在列表出现的次数
    list.extend(seq) 在末尾添加新列表,扩展列表
    list.index(obj) 在列表中找出某个值第一个匹配性的索引位置
    list.insert(index,obj) 将对象插入列表,其中的index,为插入的位置,原来该位置后面的元素包含该位置元素,都统一后移
    list.pop(obj=list[-1])
    有默认参数,即最后一项 删除指定位置元素并返回,他和del的区别在于del是一个关键字。而pop是内建函数,我们无法用变量去接收del删除的项 (参数可以不写,默认删除最后一项)
    list.remove(obj) 移出列表中某个值第一次匹配的项
    list.reverse() 反向列表中的元素(收尾互换),不代表倒序排列!
    list.sort() 对列表进行排序
    list.copy() 复制列表
    list.clear() 清空列表

    Set集合
    集合是一个无序不重复元素的序列
    基本功能就是进行成员关系测试,和删除重复元素 (所谓成员关系测试就是查看他们是否重复,两个集合的交集…)
    可以使用 { } 或者set()函数来创建集合 但是创建一个空集合必须适用set()
    请添加图片描述

    编程语言的进化:机器语言、汇编语言、高级语言

    机器语言:由于计算机内部只能接受二进制代码,因此,用二进制代码0或1描述的指令称为机器指令,全部机器指令的集合构成计算机的机器语言。

    汇编语言:实质和机器语言是相同的,都是直接对硬件操作,只不过指令采用英文缩写的标识符,更容易识别和记忆。

    高级语言:高级语言对开发人员更加友好,开发效率大大提高

    高级语言所编制的程序不能直接被计算机识别,必须经过转换才能被执行。

    高级语言按转换方式可分为:编译型、解释型

    编译型:指在应用源程序执行之前,将程序源代码转换成目标代码,因此其目标代码可以脱离其语言环境独立执行。

    编译后程序运行时不需要重新翻译,直接使用翻译的结果就行。程序执行效率高,依懒性编译器,跨平台性差。如C、C++、GO、Delphi等

    解释型:应用程序源代码一边由相应语言的解释器翻译成目标代码,一边执行,因此效率比较低,不能生成可独立执行的可执行文件,应用程序不能脱离其解释器。如Python、Java、PHP、Ruby等。跨平台性好、开发效率不高。

    编译型语言执行速度快,不依赖语言环境运行,跨平台差

    解释型跨平台好,一份代码,到处运行。缺点是执行速度慢,依赖解释器运行。

    Python创始人:Guido van Rossum(龟叔)

    Python诞生在1989年

    2008年12月出现Python3.0

    2010年出现一个过渡版本Python2.7(最多只支持到2020年,之后不支持2.0版本)

    Python解释器是用C语言写的

    Python解释器种类有:CPython、IPython、PyPy、Jython、IronPython

    测试安装是否成功:

    windows–>运行–>输入cmd,回车,弹出cmd程序,输入Python,如果进入交互环境,代表安装成功。

    print(‘hello world!’)

    保存为helloworld.py,注意.py后缀名的作用:命名约束规范,方便程序员识别代码。

    进入cmd命令行,执行Python helloworld.py,看结果。

    注意文件名前面加python的原因是要把代码交给python解释器去解释执行

    内存和磁盘的关系:内存存取速度快,断电就丢失;磁盘存取速度慢,永久保存。

    Python交互器是主要用来对代码进行调试用的

    变量:先定义后使用

    变量作用:存数据,占内存,存储程序运行的中间结果,可以被后面的代码调用。

    声明变量:变量名=变量的值

    变量的命名规则:

    1.变量名只能是数字、字母或下划线的任意组合

    2.变量名的第一个字符不能是数字

    3.以下关键字不能声明为变量名[‘and’,‘as’,‘assert’,‘break’,‘class’,‘continue’,‘def’,‘elif’,‘else’,‘except’,‘exec’,‘finally’,‘for’,‘from’,‘global’,‘if’,‘import’,‘in’,‘is’,‘lambda’,‘not’,‘or’,‘pass’,‘print’,‘raise’,‘return’,‘try’,‘while’,‘with’,‘yield’]

    常量:程序在执行过程中不能改变的量

    在Python中没有一个专门的语法代表常量,程序员约定俗成的变量名全部大写代表常量。

    读取用户输入

    name = input(“what’s your name:”)print(“hello”+name)

    输入用户姓名和密码

    username= input(“username:”)

    password= input(“password:”)print(username,password)

    注释:解释说明,帮助阅读代码。

    单行注释:#

    多行注释:‘’‘…’‘’

    数据类型

    数据类型-数字类型

    int(整型):32位机器上:-231 —— 231-1 64位同样的道理

    long(长整型):Python的长整型没有指定位宽。(Python3里不再有long类型)

    float(浮点型):

    数据类型-字符串类型

    字符串:在Python中,加了引号的字符都被认为是字符串!

    注意:单双引号是没有任何区别的;多行字符串必须用多引号。

    布尔类型:

    只有两个值True、False ,主要用来做逻辑判断

    格式化输出:(%s 以一个字符替换 %d以一个整数替换 %f以一个浮点数替换)都是一个占位符 %是一个连接符

    运算符

    算术运算符(+,-,*,/,%,**,//),

    比较运算符(==,!=,<>,>,<,>=,<=),

    逻辑运算符(and,or,not),

    赋值运算符(=,+=,*=,/=,%=,**=,//=),

    成员运算符(in,not in),

    身份运算符(is , is not),

    位运算(>>,<<)

    流程控制

    单分支:

    if 条件:

    满足条件后要执行的代码块

    多分支:

    if 条件:

    满足条件后要执行的代码块

    elif 条件:

    上面的条件不满足就走这个

    elif 条件:

    上面的条件不满足就走这个

    elif 条件:

    上面的条件不满足就走这个

    else:

    上面的条件不满足就走这个

    while循环

    while 条件:

    执行代码…

    Dead Loop

    count=0

    while True:

    print(“你个基佬!!!”,count)

    count+=1

    循环终止语句:break语句或continue语句

    break语句:用于完全结束一个循环,跳出循环体执行后面的语句

    continue语句:只终止本次循环,接着执行后面的循环

    while…else用法

    当while循环正常执行完,中间没有被break终止的话,就会执行else后面的语句。

    二进制运算、字符编码、数据类型

    二进制(0,1)、八进制(0-7)、十进制(0-9)、十六(0-9,A-F)进制的转换

    四位二进制表示一位十六进制

    oct() 八进制 hex()十六进制

    char(num)将ASCII值得数字转换成ASCII字符,范围只能是0-255

    ord(char)接受一个ASCII值字符,返回相应的ASCII值

    每一位0或1所占的空间单位为bit(比特),这是计算机中最小的表示单位

    8bits = 1Bytes字节,最小的存储单位,1bytes缩写为1B

    1024Bytes = 1KB = 1KB

    1024KB = 1MB

    1024MB =1GB

    1024GB = 1TB

    1024TB = 1PB

    ASCII 256,每一个字符占8位

    Unicode编码(统一码、万国码):规定了所有的字符和符号最少由16位表示

    UTF-8:ascii码中的内容用1个字节保存,欧洲的字符用2个字节保存,东亚的字符用3个字节保存…

    winsows系统中文版默认编码是GBK

    Mac OS\Linux系统默认编码是UTF-8

    UTF是为unicode编码 设计的一种在存储和传输时节省空间的编码方案。

    无论以什么编码在内存里显示字符,存到硬盘上都是二进制。不同编码的二进制是不一样的

    存到硬盘上以何种编码存的,那么读的时候还得以同样的编码读,否则就乱码了。

    python2.x默认编码是ASCII;默认不支持中文,支持中文需要加:#* coding:utf-8 * 或者 #!encoding:utf-8

    Python3.x默认编码是UTF-8,默认支持中文

    Python数据类型

    字符串 str

    数字:整型(int)长整型(long) 浮点型(float) 布尔(bool) 复数(complex)

    列表 list

    元组 tuple

    字典 dictionary

    集合:可变集合(set) 不可变集合(frozenset)

    不可变类型:数字,字符串,元组

    可变类型:列表,字典,集合

    899590-20180512120213031-26929447.png

    字符串

    特点:有序、不可变

    字符串的常用方法:isdigit,replace,find,count,index,strip,split,format,join,center

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 s = “abcd”

    2 print(s.swapcase()) #都变成大写字母

    3

    4 print(s.capitalize()) #都变成首字母大写

    5

    6 print(s.center(50,"")) #打印变量s的字符串 指定长度为50,字符串长度不够的用号补齐

    7

    8 print(s.count(“a”,0,5)) #统计字符串a在变量里有几个;0,5代表统计范围是下标从0-5的范围

    9

    10 print(s.endswith(“!”)) #是否是以什么结尾的。

    11

    12 print(s.startswith(“a”)) #判断以什么开始

    13

    14

    15 s = “a b”

    16 print(s.expandtabs(20)) #相当于在a和b中间的tab长度变成了20个字符,交互模式可看出效果

    17

    18 s.find(“a”,0,5) #查找字符串,并返回索引

    19

    20 s.format() #字符串格式化

    21 s1 = “my name is {0},i am {1} years old”

    22 print(s1)23 print(s1.format(“aaa”,22)) #分别把{0}替换成aaa {1}替换成22

    24 #也可以写成如下

    25 s1 = “my name is {name},i am {age} years old”

    26 s1.format(name=“aaa”,age = 22) #字典形式赋值

    27

    28 #s.format_map() #后续补充

    29

    30

    31 print(s.index(“a”)) #返回索引值

    32

    33 print(s.isalnum()) #查看是否是一个阿拉伯字符 包含数字和字母

    34

    35 print(s.isalpha()) #查看是否是一个阿拉伯数字 不包含字母

    36

    37 print(s.isdecimal()) #判断是否是一个整数

    38

    39 print(s.isdigit()) #判断是否是一个整数

    40

    41 print(s.isidentifier()) #判断字符串是否是一个可用的合法的变量名

    42

    43 print(s.islower()) #判断是否是小写字母

    44

    45 print(s.isnumeric()) #判断只有数字在里边

    46

    47 print(s.isprintable()) #判断是否可以被打印,linux的驱动不能被打印

    48

    49 print(s.isspace()) #判断是否是一个空格

    50

    51 print(s.istitle()) #判断是否是一个标题 每个字符串的首字母大写 Hello Worlld

    52

    53 print(s.isupper()) #判断是否都是大写

    54

    55 #s.join()

    56 name = [“a”,“b”,“1”,“2”]57 name2 = “”.join(name) #列表转成字符串,把列表里边的元素都join到字符串中

    58 print(name2) #得出ab12

    59

    60 #s.ljust

    61 s = “Hello World”

    62 print(s.ljust(50,“-”)) #给字符串从左往右设置长度为50,字符串长度不够用 - 补充

    63

    64 print(s.lower()) #字符串都变成小写

    65

    66 print(s.upper()) #变大写

    67

    68 print(s.strip()) #脱掉括号里边的,可以是空格 换行 tab …

    69

    70 s.lstrip() #只脱掉左边的空格

    71 s.rstrip() #只拖点右边的空格

    72

    73 #s.maketrans() #

    74 str_in = “abcdef” #必须是一一对应

    75 str_out = “!@#$%^” #必须是一一对应

    76 tt = str.maketrans(str_in,str_out) #生成对应表,就像密码表一样

    77 print(tt)78 #结果:{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}

    79

    80 print(s.translate(tt)) #s.translate方法调用 加密方法tt 给 s的字符串加密

    81 #结果:H%llo Worl$

    82

    83 #s.partition()

    84 s = “Hello World”

    85 print(s.partition(“o”)) #把字符串用 从左到右第一个o把 字符串分成两半

    86 #结果:(‘Hell’, ‘o’, ’ World’)

    87

    88 s.replace(“原字符”,“新字符”,2) #字符串替换,也可以写换几次 默认全换,可以设置count次数

    89

    90 s.rfind(“o”) #查找最右边的字符,也有开始和结束

    91

    92 print(s.rindex(“o”) ) #查找最右边的字符的索引值

    93

    94 s.rpartition(“o”) #从最右边的字符开始 把字符串分成两半

    95

    96 s.split() #已括号里边的把字符串分成列表,括号里可以是空格、等字符来分成列表

    97

    98 s.rsplit() #从最右边以 某字符 来分开字符串

    99

    100 s.splitlines() #设置以换行的形式 把字符串分成列表

    101

    102 print(s.swapcase()) #字母换成相反的大小写,大的变成小,小的变成大

    103 #结果“:hELLO wORLD

    104 #原来的“hello World”

    105

    106 s.title() #把字符串变成title格式 Hello World

    107

    108 s.zfill(40) #把字符串变成40,字符串不够,从左往右用0 补齐

    109

    110

    111 #“a\tb” 字符串中间的\t 被认为是tab 是4个或者8个空格

    112 #整体意思是:a 有一个tab 然后 又有一个b

    View Code

    列表

    列表的常用方法:创建、查询、切片、增加、修改、删除、循环、排序、反转、拼接、clear、copy

    列表的特点:可以重复;列表是有序的

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 1、创建2 ​ 方法一:list1 = [“a”, “b”]   #常用

    3 ​ 方法二:list2 = list ()     #一般不用这种方法

    4

    5 2、查询6 ​ 列表的索引 (也称下标):7 列表从左到右下标是从0开始0、1、2、3…8 ​列表从右到左下标是从 - 1开始 -1 -2 -3…9

    10 ​查询索引值:11 ​list1.index (a)    #index查询找到第一个a程序就不走了,

    12 list1[0]    #通过a的索引 得出a

    13 list1[-1]   #通过b的下标 得出b

    14

    15 当list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]16 列表里出现元素相同时,统计相同次数17 list1.count (4)    #统计得出:6 代表列表有6个4

    18

    19 3、切片20 切片:通过索引 (或下标)21 截取列表中一段数据出来。22 list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]23 list1[0:2]    #得出 [1,2] ,列表切片顾头不顾尾,也可成list1[:2]

    24 list1[-5:]    #得出[4,4,4,4,4],取最后5个元素,只能从左往右取

    25 按步长取元素:26 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]27 list1[:6:2]    #得出:[1, 3, 5]   :2 代表步长 ,每隔两步取一个元素

    28 list1[::2]    #得出:[1, 3, 5, 1, 3, 5]  在列表所有元素中,每隔2步取一个数

    29

    30 4、增加31 list1 = [“a”, “b”, “c”]32 list1.append (“d”)    #追加d到列表list1的最后 结果:[‘a’, ‘b’, ‘c’, ‘d’]

    33 list1.insert (1, “aa”)    #插入aa到列表下标为1的之前   得出结果:[‘a’, ‘aa’, ‘b’, ‘c’, ‘d’]

    34

    35 5、修改36 list1[1] = “bb”    #直接给对应位置赋值,即是修改 结果:[‘a’, ‘bb’, ‘b’, ‘c’, ‘d’]

    37 批量修改38 把[‘a’, ‘bb’, ‘b’, ‘c’, ‘d’]里的前两个元素替换掉39 list1[0:2] = “boy”    #结果:[‘b’, ‘o’, ‘y’, ‘b’, ‘c’, ‘d’]

    40

    41 6、删除42 list1 = [‘b’, ‘o’, ‘y’, ‘b’, ‘c’, ‘d’]43 list1.pop ()    #默认删除最后一个元素 d

    44 list1.remove (“o”)    #删除元素O remove只能一个一个删除

    45 list1.remove (0)    #删除下标为0的元素 b

    46 del list1[0]    #删除下标为0的元素 del是一个全局删的方法

    47 del list1[0:2]    #del可以批量删除

    48

    49 7、for循环列表50 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]51 for i in list1: #使用for循环循环列表list1里边的元素

    52 range (10)    #生成0到10 的数字

    53

    54 8、排序55 list1 = [“1”, “5”, “3”, “a”, “b”, “f”, “c”, “d”, “A”, “C”, “B”]56 list1.sort () #结果:[‘1’, ‘3’, ‘5’, ‘A’, ‘B’, ‘C’, ‘a’, ‘b’, ‘c’, ‘d’, ‘f’]

    57

    58 排序是按照ASCII码对应排序。59 反转60 list1.reverse () #结果:[‘f’, ‘d’, ‘c’, ‘b’, ‘a’, ‘C’, ‘B’, ‘A’, ‘5’, ‘3’, ‘1’]

    61

    62 9、两个列表拼一块63 #方法一

    64 list1 = [1, 2, 3, 4, 5]65 list2 = [6, 7, 8, 9]66 list1 + list2 #结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]

    67 #​方法二

    68 list1.extend (list2)    #把列表2扩展到list1中

    69 结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]70

    71 10、clear72 #清空列表

    73 list2.clear ()    #清空list2

    74

    75 11、copy76 浅copy77 复制列表78 list2 =list1.copy ()79 当列表只有一层数据,没有列表嵌套列表的情况下,复制后的列表和原来的列表是完全独立的。80 当列表有多层嵌套的时候,列表嵌套里边的列表的内容是和原有列表是共享的。81 list1.copy () #所以这个叫做:浅copy

    82

    83 ​深copy:需要借助python模块84 importcopy85 list2 =copy.deepcopy (list1)86 深copy后,新的列表和旧的列表,不管有没有列表嵌套列表,都是完全独立的个体。87 可以通过查看列表名对应的内存地址分辨两个列表是否独立88 查看python解释器里边的内存地址:id (变量名)

    View Code

    元组

    特点:有序的,不可变的列表

    常用功能:index,count,切片

    使用场景:显示的告知别人,此处数据不可修改;数据库连接配置信息等

    hash函数

    hash,一般翻译为“散列”,也有直接翻译为“哈希”的,就是把任意长度的输入,通过散列算法,变成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不通的输入可能会散列成相同的输出,所以不可能从散列值来确定唯一的输入值,简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

    特征:hash值的计算过程是依据这个值的一些特征计算的,这就要求被hash的值必须固定,因此被hash的值必须是不可变的。(不能保证输出的数据唯一的,容易造成冲突)

    用途:文件签名;md5加密;密码验证

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 >>> hash(“abc”)2 -6784760005049606976

    3 >>> hash((1,2,3))4 2528502973977326415

    View Code

    字典

    语法:info={}

    特点:1.key-value结构,key必须是可hash、必须是不可变数据类型、必须唯一

    2.每一个key必须对应一个value值,value可以存放任意多个值,可修改,可以不唯一

    3.字典是无序的

    字典的查找速度快是因为字典可以把每个key通过hash变成一个数字(数字是按照ASCII码表进行排序的)

    字典的方法:增删改查 多级嵌套 等

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 #字典方法

    2 info ={3 “student01”:“aaa”,4 “student02”:“bbb”,5 “student03”:“ccc”

    6 }7

    8 #增加

    9 info[“student04”] = “ddd”

    10 info[“student05”] = “eee”

    11 info[“student06”] = “fff”

    12

    13 #查询

    14 #判断student01在不在info字典里

    15 print(“student01” in info ) #返回True

    16 print(info.get(“student01”)) #返回aaa,没有返回None

    17 info[“student01”] #获取对应的value ,如果没有这个key 就报错,所以一般用get

    18

    19 #删除

    20 print(info.pop(“student01”)) #删除key

    21 print(info.popitem()) #随机删除一个key

    22 del info[“student02”] #删除的key ,如果没有删除的key 就报错 KeyError: ‘student01’

    23

    24 info.clear() #清空字典

    25

    26 #多级字典嵌套

    27 dic1 = {“aaa”: {“aa”: 11}, “bbb”: {“bb”: 22}}28

    29 #其他方法

    30 info ={31 “name1”: [22, “it”],32 “name2”: [24, “hr”],33 “name3”: 33

    34 }35

    36 info2 ={37 “name1”: 44,38 “name4”: 33,39 1: 2

    40 }41 info.keys() #打印所有的key

    42 info.values() #打印所有的value

    43 info.items() #把字典转成一个列表

    44 info.update(info2) #把两个字典合成一个,如果有重复的key ,info2里边的重复key会覆盖info里边的key

    45 info.setdefault(“student07”,“abcdef”) #设置一个默认的key:value ,

    46 #如果info字典里没有key student07 ,那么info字典里有添加 student07:abcdef

    47 #如果info字典里已经手动添加了student07的key value,那么这里的student07:abcdef 就不起作用

    48 print(info.fromkeys([“name1”,“name2”],“aaa”) ) #从一个可迭代的对象中批量生成key和相同的value

    49

    50 #字典的循环:高效循环

    51 for k ininfo:52 print(k,info[k]) #打印key value

    53

    54 #另外一种方法 低效

    55 for k,v in info.items(): #先把字典转成列表,在循环,所以低效

    56 print(k,v)

    View Code

    集合

    集合是一个无序的、不重复的数据组合

    作用:1.去重

    2.关系测试,测试两组数据之间的交集、差集、并集等关系

    语法:

    s = {} #如果为空,就是字典

    s = {1,2,3,4} #就成了集合 set

    s = {1,2,3,4,1,2} #有重复数据,显示结果就直接去重{1, 2, 3, 4}

    列表转成给一个字典

    l = [1,2,3,4,1,2]

    l2 = set(l)

    集合的方法

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 #集合方法

    2 s = {1,2,3,4,5} #定义一个集合

    3

    4 #增加

    5 s.add(6)6 print(s) #{1, 2, 3, 4, 5, 6}

    7

    8 #删除

    9 #随机删除

    10 s.pop()11 print(s) #{2, 3, 4, 5, 6}

    12 #指定删除,如果不存在,就报错

    13 s.remove(6)14 print(s) #{2, 3, 4, 5}

    15 #指定删除,如果不存在,不报错

    16 s.discard(6)17 print(s)18

    19 #联合其他集合,可以添加多个值

    20 s.update([7,8,9])21 print(s) #{2, 3, 4, 5, 7, 8, 9}

    22

    23 #清空集合

    24 s.clear()25

    26

    27 #集合的关系测试

    28 iphone7 = {“alex”,“rain”,“jack”,“old_driver”}29 iphone8 = {“alex”,“shanshan”,“jack”,“old_boy”}30

    31 #交集

    32 print(iphone7.intersection(iphone8))33 print(iphone7 &iphone8)34 #输出:

    35 {‘jack’, ‘alex’}36 {‘jack’, ‘alex’}37

    38 #差集

    39 print(iphone7.difference(iphone8))40 print(iphone7 -iphone8)41 #输出:

    42 {‘rain’, ‘old_driver’}43 {‘rain’, ‘old_driver’}44

    45 #并集 把两个列表加起来

    46 print(iphone7.union(iphone8))47 print(iphone7 |iphone8)48 #输出:

    49 {‘rain’, ‘jack’, ‘old_driver’, ‘alex’, ‘shanshan’, ‘old_boy’}50 {‘rain’, ‘jack’, ‘old_driver’, ‘alex’, ‘shanshan’, ‘old_boy’}51

    52 #对称差集 把不交集的取出来

    53 print(iphone7.symmetric_difference(iphone8))54 #输出:

    55 {‘rain’, ‘old_driver’, ‘shanshan’, ‘old_boy’}56

    57 s = {1,2,3,4}58 s2 = {1,2,3,4,5,6,}59 #超集 谁是谁的父集

    60 print(s2.issuperset(s)) #s2是s的父集

    61 print(s2 >=s)62 #输出:

    63 True64 True65

    66 #子集

    67 print(s.issubset(s2)) #s是s2的子集

    68 print(s <=s2)69 #输出:

    70 True71 True72

    73 #判断两个集合是否不相交

    74 print(s.isdisjoint(s2))75 #输出:

    76 False #代表两个集合是相交的

    77

    78 s = {1,2,3,-1,-2}79 s2 = {1,2,3,4,5,6}80 s.difference_update(s2) #求出s和s2 的差集,并把差集 覆盖给 s

    81 print(s) #结果:{-2, -1}

    82

    83 s.intersection_update(s2) #求出s和s2的交集,并把交集 覆盖给 s

    84 print(s)85 print(s2)86 #结果:

    87 {1, 2, 3}88 {1, 2, 3, 4, 5, 6}

    View Code

    字符编码

    python3

    文件编码默认 :utf-8

    字符串编码:unicode

    python2

    文件编码默认:ascii

    字符串编码默认:ascii

    如果文件头声明了utf-8,那字符串的编码是utf-8

    unicode是一个单独的类型

    python3的内存里:全部是unicode

    python3执行代码的过程:

    1、解释器找到代码文件,把代码字符串按文件头定义的编码加载到内存,转成unicode

    2、把代码字符串按照python语法规则进行解释

    3、所有的变量字符都会以unicode编码声明

    在python2里边,默认编码是ASCII编码,那么文件头声明是utf-8的代码,在windows中将显示乱码

    如何在windows上显示正常呢?(windows的默认编码是gbk)

    1、字符串以gbk格式显示

    2、字符串以unicode编码

    修改方法:

    1.UTF-8 – >decode解码 --> Unicode

    2.Unicode – > encode编码 – > GBK / UTF-8

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 s=“路飞学城”

    2 print(“decode before:”,s)3 s2=s.decode(“utf-8”)4 print(“decode after:”,s2)5 print(type(s2))6 s3=s2.encoded(“gbk”)7 print(s3)8 print(type(s3))

    View Code

    python中bytes类型

    二进制的组合转换成16进制来表示就称之为bytes类型,即字节类型,它把8个二进制组成一个bytes,用16进制来表示。

    在python2里,bytes类型和字符串是本质上时没有区分的。

    str = bytes

    python2 以utf-8编码的字符串,在windows上不能显示,乱码。

    如何在python2下实现一种,写一个软件,在全球各国电脑上 可以直接看?

    以unicode编码写软件。

    s = you_str.decode(“utf-8”)

    s2= u"路飞"

    unicode类型 也算字符串

    文件头:

    python2:以utf-8 or gbk 编码的代码,代码内容加载到内存,并不会被转成unicode,编码依然是utf-8 或 gbk。

    python3:以utf-8 or gbk编码的代码,代码内容加到在内存,会被自动转成unicode。

    在python3里,bytes类型主要来存储图片、视频等二进制格式的数据

    str = unicode

    默认就支持了全球的语言编码

    常见编码错误的原因有:

    1、python解释器的默认编码

    2、python源文件文件编码

    3、终端使用的编码(windows/linux/os)

    4、操作系统的语言设置
    一、模块、包

    1、什么是模块?

    1、把相同功的函数放在一个py文件里,称为模块。

    2、一个PY文件就称为一个模块。

    3、模块有什么好处:

    1、容易维护。

    2、减少变量和函数名冲突。

    4、模块种类:

    1、第三方模块——别人写的模块

    2、内置模块——编译器自带模块(如:os、sys、等)

    3、自定义模块——自己编写的模块

    5、模块怎么导入:

    通过import命令导入,eg:import os(模块名)

    2、什么是包?

    1、把多个模块放在同一个文件夹内,这个文件夹称为包。

    2、文件夹称为包还有一个条件——文件夹里要有__init__.py模块。

    3、模块与包有什么区别

    1、模块——一个py文件就称一个模块

    2、包——一个包含有__init__.py的文件夹称为一个包;一个包里可以有多个py模块。

    json、pickle

    1、什么是序列化?

    1、把内存数据转换成字符串。

    1、把内存数据保存到硬盘。

    2、把内存数据传输给他人(由于网络传输是通过二进制传输,所以需要进行转换)。

    2、序列化的模块有两个,json和pickle

    2、json、pickle有什么优点和缺点?

    1、json——把json所支持的数据转换成字符串

    优点:体积小、跨平台。

    缺点:只支持int、str、list、dict、tuple等类型。

    2、pickle——把python所支持的所有类型转换成字符串

    优点:支持python 全部数据类型

    缺点:只能在python平台使用,占用空间大。

    3、json和pickle有4个方法

    load 、loads 、dump 、dumps

    load:通过open函数的read文件方法,把内存数据转成字符串

    loads:把内存数据转成字符串

    dump:通过open函数的write文件方法,把字符串转换成相应的数据类型。

    dumps:把字符串数据转成相应的数据类型。

    shelve

    1、什么是shelve?

    1、shelve是一种key,value 形式的文件序列化模块;序列化后的数据是列表形式。

    2、底层封装了pickle模块,支持pickle模块所支持的数据类型。

    3、可以进行多次反序列化操作。

    hashlib

    1、什么是hashlib?

    hashlib 模块——也称‘哈希’模块。

    通过哈希算法,可以将一组不定长度的数据,生成一组固定长度的数据散列。

    特点:

    1、固定性——输入一串不定长度的数据,生成固定长度的数字散列。

    2、唯一性——不同的输入所得出的数据不一样。

    2、md5

    输入一串不定长度的数据,生成128位固定长度的数据。

    特点:

    1、数字指纹——输入一串不定长度的数据,生成128位固定长度的数据(数字指纹)。

    2、运算简单——通过简单的运算就可以得出。

    3、放篡改——改动很少,得出的值都会不一样。

    4、强碰撞——已知MD5值,想找到相同的MD5值很难。

    函数

    1、什么是函数?

    把代码的集合通过函数名进行封装,调用时只需要调用其函数名即可。

    有什么好处:

    1、可扩展

    2、减少重复代码

    3、容易维护

    2、函数的参数?

    函数可以带参数:

    形参:

    1、在函数定义是指定。

    2、函数调用时分配内存空间,函数运行结束,释放内存空间。

    实参:

    1、形式可以是常量、变量、表达式、函数等形式。

    2、无论是何种形式,都必须要有明确的值,以便把数据传递给形参。

    默认参数:

    1、函数定义时可以指定默认参数(eg: def func(a,b=1))

    2、传参时指定了默认参数,就使用传参时的值,没有指定,则使用默认参数的值。

    关键参数:

    1、函数传参时需按顺序传参,如果不按顺序传参可以使用关键参数传参。

    非固定参数:

    1、当不确定参数的数量时可以使用非固定参数。

    2、非固定参数有两种:1.*args——(传入的参数以元组表示)。2.**kwargs——(传入的阐述用字典表示)

    3、函数的返回值

    1、函数可以把运算的结果返回。

    2、函数可以有返回值,也可以没有返回值。

    有返回值——通过return返回。

    没有返回值——返回值为None

    3、函数遇到return,代表函数运行结束。

    4、函数的种类

    嵌套函数——一个函数包含了另一个函数。

    高阶函数——一个函数的参数引用了另一个函数,一个函数的返回值是另一个函数。

    匿名函数——不用显式指定函数名的函数(lambrda),常和map和filter配合使用。

    递归函数

    1、函数内部引用了函数自身

    2、函数里有一个明确的结束条件。

    递归函数的特性:

    1、有一个明确的结束条件

    2、每次递归的规模都应有所减少

    3、递归函数的效率不高。

    作用域

    1、名称空间

    名称空间就是存放变量名和变量值(eg:x=1)绑定关系的地方。

    1、名称空间种类:

    local:函数内部,包括形参和局部变量。

    global:函数所在模块的名字空间。

    buildin:内置函数的名字空间。

    2、变量名的作用域范围的不同,是由这个变量名所在的名称空间所决定的。

    全局范围:全局存活,全局有效。

    局部范围:局部存活,局部有效。

    2、作用域查找顺序

    作用域查找顺序:

    local——》enclosing function——》global——》builtin

    local:函数内部,包括形参、局部参数。

    enclosing function:内嵌函数。

    global:函数所在模块。

    builtin:内置函数。

    闭包

    1、什么是闭包

    1、一个嵌套函数,分别有内函数,外函数。

    2、内函数使用了外函数的变量。

    3、外函数返回了内函数的应用地址。

    4、那么这个嵌套函数就称为闭包。

    2、闭包有什么意义

    1、闭包返回的对象不仅仅是一个对象,而且还返回了这个函数的外层包裹的作用域。

    2、无论这个函数在何处被调用,都优先使用其外层作用域。

    装饰器

    1、什么是装饰器

    1、装饰器本质上就是一个闭包函数。

    2、装饰器的作用是,在不改变原有函数的调用方式下,增加代码的功能。

    结束语 🥇🥇🥇
    推荐一款模拟面试、Python刷题神器网站点击链接注册即可
    1、算法篇(398题):面试必刷100题、算法入门、面试高频榜单
    2、SQL篇(82题):快速入门、SQL必知必会、SQL进阶挑战、面试真题
    3、大厂笔试真题:字节跳动、美团、百度、腾讯…

    不喜勿喷,喜欢的点个赞呗!

    展开全文
  • Python知识点总结

    千次阅读 多人点赞 2020-12-27 18:26:36
    Python知识点总结1.Python基础知识1.1 变量及类型1.2 标识符与关键字1.3 常用格式化输出符号1.4 运算符1.4.1 算数运算符1.4.2 赋值运算符1.4.3 比较(即关系)运算符1.4.4 逻辑运算符1.5 数据类型转换1.6 判断与循环...

    1.Python基础知识

    1.1 变量及类型

    变量:用来存储数据,常见类型如下。
    在这里插入图片描述

    1.2 标识符与关键字

    标识符:是自己定义的,如变量名 、函数名等, 命名规则如下。

    1. 小驼峰式命名法(lower camel case): 第一个单词以小写字母开始;第二个单词的首字母大写,例如:myName、aDog;
    2. 大驼峰式命名法(upper camel case): 每一个单字的首字母都采用大写字母,例如:FirstName、LastName;
    3. 用下划线“_”来连接所有的单词,比如send_buf;

    关键字:

    python一些具有特殊功能的标识符,就是所谓的关键字,是python已经使用的了,所以不允许开发者自己定义和关键字相同的名字的标识符。

    可以通过如下命令查看当前系统中python的关键字:

    import keyword
    keyword.kwlist
    

    Python中的常见关键字:

    and     as      assert     break     class      continue    def     del
    elif    else    except     exec      finally    for         from    global
    if      in      import     is        lambda     not         or      pass
    print   raise   return     try       while      with        yield
    

    1.3 常用格式化输出符号

    在这里插入图片描述

    1.4 运算符

    1.4.1 算数运算符

    在这里插入图片描述

    1.4.2 赋值运算符

    在这里插入图片描述

    1.4.3 比较(即关系)运算符

    在这里插入图片描述

    1.4.4 逻辑运算符

    在这里插入图片描述

    1.5 数据类型转换

    在这里插入图片描述
    常用字符与ASCII码对照表:
    在这里插入图片描述

    1.6 判断与循环语句

    1、判断语句:

    if…elif…else

    2、循环语句:

    while…

    for…in…
    注意:for遍历列表时,不能与删除一起使用,否则会造成漏掉遍历的情况

    break 和 continue
    break 的作用:立刻结束break所在的循环
    continue 的作用:用来结束本次循环,紧接着执行下一次的循环
    break/continue 只能用在循环中,除此以外不能单独使用;在嵌套循环中,只对最近的一层循环起作用

    1.7 字符串、列表、元祖、字典

    1.7.1 公共方法

    1、下标和切片

    1. 下标索引:字符串、列表、元组都支持下标索引,索引形式:name[i],i从0开始计数。

    2. 切片:切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

    切片的语法:[起始:结束:步长]
    字符串名[m:n:k] 从下标为m到下标为n-1,每k个取1个
    注意:选取的区间从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身),步长表示选取间隔。

    2、运算符

    在这里插入图片描述

    3、python内置函数

    在这里插入图片描述
    4、相互转换

    set, list, tuple 三者可以相互转换

    set可以快速完成对list中元素去重

    1.7.2 字符串常见操作

    在这里插入图片描述

    1.7.3 列表基本操作

    在这里插入图片描述

    1.7.4 元组

    python中通过下标访问元组中元素,不允许修改元组的数据,包括不能删除其中的元素。

    查看元组通过:index/count
    index和count与字符串和列表中的用法相同

    1.7.5 字典常见操作

    在这里插入图片描述

    1.8 函数

    在这里插入图片描述

    1.9 文件操作

    1、访问格式

    打开文件:f = open("文件名","访问模式"), f = open('test.txt', 'w')
    关闭文件: f.close()
    

    2、文件指针

    f.tell(): 返回一个是数字,表示文件指针当前所在的位置
    

    3、访问模式

    在这里插入图片描述
    4、文件读写与备份

    在这里插入图片描述

    5、文件相关操作

    在这里插入图片描述

    1.10 面向对象

    1.10.1 概念

    在这里插入图片描述

    1.10.2 命名、分类、属性与方法

    类名命名规则:大驼峰命名法

    新式类与经典类:
    在这里插入图片描述
    属性与方法:
    在这里插入图片描述

    1.10.3 私有权限

    在这里插入图片描述

    1.10.4 魔法方法

    在这里插入图片描述

    1.10.5 继承

    在这里插入图片描述

    1.10.6 类属性与实例属性

    在这里插入图片描述

    1.10.7 类方法和静态方法

    在这里插入图片描述

    1.10.8 单例模式

    确保某一个类只有一个实例,通常应用于回收站。

    1.11 异常与模块

    1.11.1 异常

    在这里插入图片描述

    1.11.2 模块

    在这里插入图片描述
    模块导入方法

    1. import module_name
      使用:module_name.函数名/变量名/类名
    2. from module_name import 函数名/变量名/类名
      使用:直接通过 函数名/变量名/类名使用
    3. from module_name import *
      使用:直接通过 函数名/变量名/类名使用

    导入包的格式

    1. import package_name.module_name as 简写
      简写.变量名/函数名/类名
    2. from package_name.module_name import 变量名/函数名/类名
      变量名/函数名/类名
    3. from package_name.module import *
      变量名/函数名/类名
    4. from package_name import module_name
      module_name.变量名/函数名/类名
    5. from package import *
      module_name.变量名/函数名/类名
    展开全文
  • 30个必考Python知识点整理

    千次阅读 多人点赞 2021-05-19 20:21:39
    考试来袭,看看这些知识点都掌握了吗? 1. a += 1 相当于 a = a + 1。 2. a, b = 2, 5 相当于 a = 2; b = 5。 3. 10/3 结果为 3.33333...,求的是10除以3的商,是一个浮点小数。 4. 10//3 结果为 3,求...

    一份问卷调查,期待听到您的声音


    考试来袭,看看这些知识点都掌握了吗?

    1. a += 1 相当于 a = a + 1。

    2. a, b = 2, 5 相当于 a = 2; b = 5。

    3. 10/3 结果为 3.33333...,求的是10除以3的商,是一个浮点小数。

    4. 10//3 结果为 3,求的是10除以3的商整数部分,又叫地板除。

    5. 17%4 结果为 1,表示取余数,17除以4商4,余数为1。

    6. 4**2 结果为 16,求4的平方。

    7. 3**3 结果为 27,求3的立方。

    8. '@'*8 的结果为 '@@@@@@@@',表示 把@重复8次得到一个新字符串。

    9. int(10.5),把小数10.5转成整数10。

    10. float(10),把整数10转成小数10.0。

    11. int("20"),把字符串"20"转成整数20。

    12. str(20),把整数20转成字符串"20"。

    13. 列表 a = [ 1, 2, 3, 4, 5, 6, 7],a[0] 为1,表示列表第一项;a[-1] 为7,表示列表最后一项;
    a[x:y] 为一个新列表,表示列表索引为x的项到索引为y-1的项组成的新列表。比如:a[1:5]表示索引为1的项到索引为5-1=4的项,即2,3,4,5组成的新列表[2,3,4,5]。
    上面的x如果省略不写,默认为开头的位置;y如果省略不写,默认到列表结束的位置。如:a[:4]结果为[1,2,3,4],a[2:]结果为[3,4,5,6,7]。(开头的位置和结束的位置,将由第三个参数方向是正还是负决定)
    a[x:y:z]第三个参数z,表示间隔,默认为1。如a[::]结果跟a一样。a[1:5:2]结果为[2,4]。求列表总长度:len(a)。

    14. 字符串的索引操作,跟列表操作类似。一个字符串,可以看作一个字符的列表。如"about"可认为是一个列表["a", "b", "o", "u", "t"]。
    元组可以看作是不可变的列表,索引切片、求长度等操作与列表类似。

    15. 在列表末尾增加一个元素:a.append(5)。

    16. 删除列表末尾的元素:a.pop()。

    17. 删除列表中索引值为i的元素:a.pop(i)。

    18. 删除列表中值为e的元素:a.remove(e),只会删除e第一次出现位置。

    19. 判断元素e是否在列表a中:e in a,如果在就会得到True,不在False。

    20. 确定元素e在列表a中的索引值:a.index(e),如果不存在,会报错,所以使用前需要先用if e in a判断一下。

    示例:

    a = [1,2,3,4]
    
    a.append(5)
    
    #此时a为[1, 2, 3, 4, 5]
    
    a.pop()
    
    #a.pop()返回值5,此时a为[1, 2, 3, 4]
    
    a.remove(2)
    
    #此时 a为[1, 3, 4]
    
    a.pop(2)
    
    #返回4,此时 a 为[1, 3]
    
    i = a.index(3)
    
    #此时i的值为1

    21. 将列表a和列表b合并:a+b,包含重复元素。

    22. 要想得到列表a中独一无二的元素用:set(a),这是一个集合,要再转成列表,需要list(set(a))强制转换。

    23. 以下a, b代表集合。

    集合的特点是:集合元素不会重复,元素之间的顺序不重要。

    而列表的特点是:列表元素可以重复,元素的顺序很重要。a - b 计算a和b的差集,即在a中而不在b中的元素构成的集合。

    24. a | b 计算a和b的并集,即在a和b中的所有元素,不重复计。

    25. a & b 计算a和b的交集,即既在a中,又在b中的元素集合。

    26. a ^ b 相当于 a | b - (a&b)。

    示例:

    a = {1,4,5,10}
    
    b = {2,5,13,20}
    
    # a - b 的值为:{1, 10, 4}
    
    # a | b 的值为:{1, 2, 4, 5, 10, 13, 20}
    
    # a & b 的值为:{5}
    
    #  a ^ b 的值为:{1, 2, 4, 10, 13, 20}

    27. 以下的a代表字典。

    字典是key(键)和value(值)一一对应的数据类型,键是不能重复的,并且键必须是不可变对象。比如:a = {'ty': 10, 'cg': 20}。其中的'ty'是一个不可变的字符串。

    28. a.keys()会返回字典所有键,但并不是一个列表类型,需要强制在外面用上list(a.keys())转换成列表。

    29. a.values()会返回字典所有值,但并不是一个列表类型,需要强制在外面用上list(a.values())转换成列表。

    30. 判断字典a中有没有某一个键k,用k in a。

    示例:

    a = {'ty': 10, 'cg': 20}
    
    #a['ty']的值为:10
    
    #list(a.keys())的值为:['ty', 'cg']
    
    #list(a.values())的值为:[10, 20]
    
    if 'cg' in a:
    
    print("Yes")
    
    for k,v in a.items():
    
        print(k, v)
    
    #输出:ty 10
    
    #cg 20

    更多资料:

    Python Turtle常用函数整理

    教育部认可|全国中小学信息技术创新与实践大赛NOC之Python编程题解一

    — OVER —

    图片

    与非学堂

    专注青少年信息技术教育,探讨少儿编程的教与学,交流技巧、分享资源

    图片

    与非学堂小程序

    蓝桥杯STEMA科技素养测试、Bebras测试、文化测试

    一份自家广告,长期有效|咨询&合作


    公众号对话框回复「HELP」更多精彩

    喜欢就请「分享「点赞「在看」吧!

    展开全文
  • 缩进缩进是指每行语句前的空白区域,用来表示Python程序间的包含和层次关系。一般语句不需要缩进,顶行书写且不留空白。当表示分支、循环、函数、类等含义,在if,while,for,def,class等保留字所在的完整语句后...
  • 1、反编译:1.1Windows下生成pyd文件(加密)[Windows下安装Python扩展提示"Unable to find vcvarsall.bat"](https://www.cnblogs.com/yyds/p/7065637.html "Windows下安装Python扩展提示"Unable ...
  • Python核心知识点总结

    2016-04-09 12:01:10
    learning Python知识总结
  • 最全Python基础的知识点复习完整版
  • 这是关于python二级常用的一些函数,还有方法,还有python要考的第三方库的方法,用于python二级考试查看记忆用。
  • python知识点讲解

    2018-08-03 18:36:40
    python知识点讲解大全python知识点讲解大全python知识点讲解大全python知识点讲解大全
  • (请结合《高教版python语言程序设计冲刺试卷(含上线题库)》) . 1.1.1python语言基本语法元素 考点一(1)程序的基本语法元素: 程序的格式框架、缩进、注释、变量、命名、保留字、数据类型、赋值语句、引用 缩进...
  • 蓝桥杯python知识点

    千次阅读 2022-03-29 17:10:36
    在这整理一下我刷题过程中用到的一些函数啊类啊啥的python知识点~ 1. count()方法 Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。 语法:str....
  • Python基础知识点梳理

    万次阅读 多人点赞 2020-02-03 22:18:11
    python常见知识点梳理 摘要: 本文主要介绍一些平时经常会用到的python基础知识点,用于加深印象。python的详细语法介绍可以查看官方编程手册,也有一些在线网站对python语法进行了比较全面的介绍,比如菜鸟教程: ...
  • Python知识点汇总思维导图

    千次阅读 多人点赞 2018-12-24 23:03:55
    总结了一下关于Python知识要点,感兴趣的朋友可以参考。 如果有错误的地方欢迎留言指出,我们共同进步 转载请声明出处。
  • Python常用知识点汇总

    千次阅读 2021-10-10 00:20:45
    今天给大家重磅推荐一个优质公众号「菜J学Python」,作者是我的好朋友J哥。其实认识J哥很长一段时间了,见证了他持续输出干货文章的点点滴滴。废话不多说,大家先点击以下卡片关注一波:点击关...
  • python基础知识点汇总

    2017-09-20 20:58:23
    python基础知识点汇总,概括性的列出python的基础知识,和一些常用的内建函数等,很基础的东西,总结了学习python第一阶段需要学习的东西。个人总结,仅供参考,后面还有进阶的知识点汇总。
  • Python复习知识点(一)

    千次阅读 2021-04-27 04:20:05
    python简介Python是一种解释型语言Python使用缩进对齐组织代码执行,所以没有缩进的代码,都会在载入时自动执行数据类型:整形 int 无限大浮点型 float 小数复数 complex 由实数和虚数组成Python中有6个标准的数据...
  • python知识点总结

    千次阅读 多人点赞 2020-08-18 12:24:57
    首先按照我的思路给大家整理了python不同的模块: 大家可以按照我总结的进行学习,下面我把传送门放在下面啦(ง ˙o˙)ว python语法元素 语法元素合集 程序控制结构 顺序结构 分支结构 循环结构 数据类型 数字类型...
  • Python期末知识点总结-Python基础

    千次阅读 2021-12-14 09:10:17
    print('Hi,python')#也可以在代码后面 ''' 多行注释 #三对双引号"""或单引号''' ''' 2.代码缩进 缩进可以用Tab键控制,也可以用空格 if x > a: print('x大于a') else: print('x小于a') print("缩进...
  • Python二级考试知识点(史上最全)

    万次阅读 多人点赞 2021-07-30 09:07:30
    Python二级考试知识点(一) 1、Python语言基本语法元素 考点1.1 程序的基本语法元素:程序的框架、缩进、注释、变量、命名、保留字、数据类型、赋值语句、库引用 33个保留字 6种数据类型 4种引用方法:import 库、...
  • Python工程师面试必备25条Python知识点

    万次阅读 多人点赞 2019-07-05 20:54:37
    下面是一些关键Python是一种解释型语言。这就是说,与C语言和C的衍生语言不同,Python代码在运行之前不需要编译。其他解释型语言还包括PHP和Ruby。 Python是动态类型语言,指的是你在声明变量时,不需要说明...
  • python爬虫基础知识点整理

    千次阅读 2020-12-18 23:31:25
    友情链接: ... 首先爬虫是什么? 网络爬虫(又被称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的...根据我的经验,要学习Python爬虫,我们要学习的共有以下几Python基础
  • 电子学会青少年编程能力等级考试Python二级考前培训手册,涵盖所有Python二级涉及的知识点,是不错的备考指南
  • Python基础知识点总结

    万次阅读 多人点赞 2017-03-23 14:53:16
    Python基础知识点

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 318,338
精华内容 127,335
关键字:

python知识点

友情链接: Densityryeedclassical.zip