zoukankan      html  css  js  c++  java
  • python 基础3

    1.集合

    主要作用: 

    1. 去重
    2. 关系测试, 交集\差集\并集\反向(对称)差集
    >>> a = {1,3,4,5,10}
    >>> b = {2,3,4,5,8}
    #交集
    >>> a & b
    {3, 4, 5}
    >>> a.intersection(b)
    {3, 4, 5}
    >>> a.intersection_update(b)
    None
    >>> a
    {3, 4, 5}
    
    
    >>> a = {1,3,4,5,10}
    #差集
    >>> b - a
    {8, 2}
    >>> a - b
    {1, 10}
    >>> a.difference(b)
    {1, 10}
    #并集
    >>> a | b
    {1, 2, 3, 4, 5, 8, 10}
    >>> a.union(b)
    {1, 2, 3, 4, 5, 8, 10}
    #对称差集
    >>> a ^ b
    {1, 2, 8, 10}
    >>> a.symmetric_difference(b)
    {1, 2, 8, 10}

    2. 元组  

    只读列表,只有count, index 2 个方法

    作用:如果一些数据不想被人修改, 可以存成元组,比如身份证列表

    3. 字典

    key-value对

    1. 特性:
    2. 无顺序
    3. 去重
    4. 查询速度快,比列表快多了
    5. 比list占用内存多

    为什么会查询速度会快呢?因为他是hash类型的,那什么是hash呢?

    哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值,这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的,所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

    dict会把所有的key变成hash 表,然后将这个表进行排序,这样,你通过data[key]去查data字典中一个key的时候,python会先把这个key hash成一个数字,然后拿这个数字到hash表中看没有这个数字, 如果有,拿到这个key在hash表中的索引,拿到这个索引去与此key对应的value的内存地址那取值就可以了。

    4. 字符编码

     先说python2

    1. py2里默认编码是ascii
    2. 文件开头那个编码声明是告诉解释这个代码的程序 以什么编码格式 把这段代码读入到内存,因为到了内存里,这段代码其实是以bytes二进制格式存的,不过即使是2进制流,也可以按不同的编码格式转成2进制流,你懂么?
    3. 如果在文件头声明了#_*_coding:utf-8*_,就可以写中文了, 不声明的话,python在处理这段代码时按ascii,显然会出错, 加了这个声明后,里面的代码就全是utf-8格式了
    4. 在有#_*_coding:utf-8*_的情况下,你在声明变量如果写成name=u"大保健",那这个字符就是unicode格式,不加这个u,那你声明的字符串就是utf-8格式
    5. utf-8 to gbk怎么转,utf8先decode成unicode,再encode成gbk

     再说python3

    1. py3里默认文件编码就是utf-8,所以可以直接写中文,也不需要文件头声明编码了,干的漂亮
    2. 你声明的变量默认是unicode编码,不是utf-8, 因为默认即是unicode了(不像在py2里,你想直接声明成unicode还得在变量前加个u), 此时你想转成gbk的话,直接your_str.encode("gbk")即可以
    3. 但py3里,你在your_str.encode("gbk")时,感觉好像还加了一个动作,就是就是encode的数据变成了bytes里,我操,这是怎么个情况,因为在py3里,str and bytes做了明确的区分,你可以理解为bytes就是2进制流,你会说,我看到的不是010101这样的2进制呀, 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装,否则让你直接看到一堆2进制,你能看出哪个字符对应哪段2进制么?什么?自己换算,得了吧,你连超过2位数的数字加减运算都费劲,还还是省省心吧。  
    4. 那你说,在py2里好像也有bytes呀,是的,不过py2里的bytes只是对str做了个别名,没有像py3一样给你显示的多出来一层封装,但其实其内部还是封装了的。 这么讲吧, 无论是2还是三, 从硬盘到内存,数据格式都是 010101二进制到-->b'xe4xbdxa0xe5xa5xbd' bytes类型-->按照指定编码转成你能看懂的文字

    编码应用比较多的场景应该是爬虫了,互联网上很多网站用的编码格式很杂,虽然整体趋向都变成utf-8,但现在还是很杂,所以爬网页时就需要你进行各种编码的转换,不过生活正在变美好,期待一个不需要转码的世界。

    5.函数

    默认参数

    看下面代码

    def stu_register(name,age,country,course):
        print("----注册学生信息------")
        print("姓名:",name)
        print("age:",age)
        print("国籍:",country)
        print("课程:",course)
    
    stu_register("王山炮",22,"CN","python_devops")
    stu_register("张叫春",21,"CN","linux")
    stu_register("刘老根",25,"CN","linux")


    发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户,像国籍这种信息,你不填写,默认就会是 中国, 这就是通过默认参数实现的,把country变成默认参数非常简单

    def stu_register(name,age,course,country="CN"):

    这样,这个参数在调用时不指定,那默认就是CN,指定了的话,就用你指定的值。

    另外,你可能注意到了,在把country变成默认参数后,我同时把它的位置移到了最后面,为什么呢?  

    关键参数

    正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名即可,但记住一个要求就是,关键参数必须放在位置参数之后。

    stu_register(age=22,name='alex',course="python",)

    非固定参数

    若你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数

    def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
        print(name,age,args)
    
    stu_register("Alex",22)
    #输出
    #Alex 22 () #后面这个()就是args,只是因为没传值,所以为空
    
    stu_register("Jack",32,"CN","Python")
    #输出
    # Jack 32 ('CN', 'Python')


    还可以有一个**kwargs

    def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
        print(name,age,args,kwargs)
    
    stu_register("Alex",22)
    #输出
    #Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
    
    stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
    #输出
    # Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

    递归

    在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。

    def calc(n):
        print(n)
        if int(n/2) ==0:
            return n
        return calc(int(n/2))
    
    calc(10)
    
    输出:
    10
    5
    2
    1    


    递归特性:

    1. 必须有一个明确的结束条件

    2. 每次进入更深一层递归时,问题规模相比上次递归都应有所减少

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

  • 相关阅读:
    use paramiko to connect remote server and execute command
    protect golang source code
    adjust jedi vim to python2 and python3
    install vim plugin local file offline
    add swap file if you only have 1G RAM
    datatables hyperlink in td
    django rest framework custom json format
    【JAVA基础】网络编程
    【JAVA基础】多线程
    【JAVA基础】String类的概述和使用
  • 原文地址:https://www.cnblogs.com/wangyufu/p/6380888.html
Copyright © 2011-2022 走看看