python基础_python基础教程 - CSDN
  • Python基本语法

    万次阅读 2019-06-14 13:55:44
    # 数据类型 print(0xff00); # 十六进制用0x前缀和0-9,a-f表示 print(1.23e9); # 对于很大或很小的浮点数,就必须用...# 在Python中,可以直接用True、False表示布尔值(请注意大小写)布尔值可以用and、or和not...

    Python基础语法总结:

    在这里插入图片描述

    1.Python标识符

    在 Python 里,标识符有字母、数字、下划线组成。

    在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。

    Python 中的标识符是区分大小写的。

    以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入;

    以双下划线开头的 foo 代表类的私有成员;以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识,如 init__() 代表类的构造函数。

    2.Python有五个标准的数据类型

    Numbers(数字)
    String(字符串)
    List(列表)
    Tuple(元组)
    Dictionary(字典)
    Python支持四种不同的数字类型:

    int(有符号整型)
    long(长整型[也可以代表八进制和十六进制])
    float(浮点型)
    complex(复数)
    python的字串列表有2种取值顺序:

    从左到右索引默认0开始的,最大范围是字符串长度少1
    从右到左索引默认-1开始的,最大范围是字符串开头
    List(列表) 是 Python 中使用最频繁的数据类型。

    列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
    列表用 [ ] 标识,是 python 最通用的复合数据类型。
    列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。
    加号 + 是列表连接运算符,星号 * 是重复操作。
    元组是另一个数据类型,类似于List(列表)。

    元组用”()”标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。
    字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。

    列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
    字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

    3.Python数据类型转换

    有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
    以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
    函数 描述
    int(x [,base])
    将x转换为一个整数
    long(x [,base] )
    将x转换为一个长整数
    float(x)
    将x转换到一个浮点数
    complex(real [,imag])
    创建一个复数
    str(x)
    将对象 x 转换为字符串
    repr(x)
    将对象 x 转换为表达式字符串
    eval(str)
    用来计算在字符串中的有效Python表达式,并返回一个对象
    tuple(s)
    将序列 s 转换为一个元组
    list(s)
    将序列 s 转换为一个列表
    set(s)
    转换为可变集合
    dict(d)
    创建一个字典。d 必须是一个序列 (key,value)元组。
    frozenset(s)
    转换为不可变集合
    chr(x)
    将一个整数转换为一个字符
    unichr(x)
    将一个整数转换为Unicode字符
    ord(x)
    将一个字符转换为它的整数值
    hex(x)
    将一个整数转换为一个十六进制字符串
    oct(x)
    将一个整数转换为一个八进制字符串

    4.Python 运算符

    算术运算符
    比较(关系)运算符
    赋值运算符
    逻辑运算符
    位运算符
    成员运算符
    身份运算符
    运算符优先级
    python算术运算符

    运算符 描述 实例

    加 - 两个对象相加 a + b 输出结果 30
    减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
    乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
    / 除 - x除以y b / a 输出结果 2
    % 取模 - 返回除法的余数 b % a 输出结果 0
    幂 - 返回x的y次幂 ab 为10的20次方, 输出结果 100000000000000000000
    // 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

    ①:python比较运算符

    以下假设变量a为10,变量b为20:

    运算符 描述 实例
    == 等于 - 比较对象是否相等 (a == b) 返回 False。
    != 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
    <> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。

    大于 - 返回x是否大于y (a > b) 返回 False。
    < 小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。 (a < b) 返回 true。
    = 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
    <= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。

    ②:Python赋值运算符

    以下假设变量a为10,变量b为20:

    运算符 描述 实例
    = 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
    += 加法赋值运算符 c += a 等效于 c = c + a
    -= 减法赋值运算符 c -= a 等效于 c = c - a
    = 乘法赋值运算符 c = a 等效于 c = c * a
    /= 除法赋值运算符 c /= a 等效于 c = c / a
    %= 取模赋值运算符 c %= a 等效于 c = c % a
    = 幂赋值运算符 c = a 等效于 c = c ** a
    //= 取整除赋值运算符 c //= a 等效于 c = c // a

    ③:Python位运算符

    下表中变量 a 为 60,b 为 13,二进制格式如下:

    a = 0011 1100
    b = 0000 1101
    a&b = 0000 1100
    a|b = 0011 1101
    a^b = 0011 0001
    ~a = 1100 0011
    运算符 描述 实例
    & 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ,二进制解释: 0000 1100
    | 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (a | b) 输出结果 61 ,二进制解释: 0011 1101
    ^ 按位异或运算符:当两对应的二进位相异时,结果为1 (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
    ~ 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1 (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
    << 左移动运算符:运算数的各二进位全部左移若干位,由”<<”右边的数指定移动的位数,高位丢弃,低位补0。 a << 2 输出结果 240 ,二进制解释: 1111 0000

    右移动运算符:把”>>”左边的运算数的各二进位全部右移若干位,”>>”右边的数指定移动的位数 a >> 2 输出结果 15 ,二进制解释: 0000 1111

    ④:Python逻辑运算符

    Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:

    运算符 逻辑表达式 描述 实例
    and x and y 布尔”与” - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 (a and b) 返回 20。
    or x or y 布尔”或” - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 (a or b) 返回 10。
    not not x 布尔”非” - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 not(a and b) 返回 False

    ⑤:Python成员运算符

    除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。

    运算符 描述 实例
    in 如果在指定的序列中找到值返回 True,否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
    not in 如果在指定的序列中没有找到值返回 True,否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

    ⑥:Python身份运算符

    身份运算符用于比较两个对象的存储单元

    运算符 描述 实例
    is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
    is not is not 是判断两个标识符是不是引用自不同对象 x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。

    # 数据类型
    print(0xff00);  # 十六进制用0x前缀和0-9,a-f表示
    print(1.23e9);  # 对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x10^9就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
    # 在Python中,可以直接用True、False表示布尔值(请注意大小写)布尔值可以用and、or和not运算。
    # 空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。
    # ----------------------------------------
    # print语句
    print('hello, world')
    print('The quick brown fox', 'jumps over', 'the lazy dog') # 遇到逗号“,”会输出一个空格
    print('100 + 200 =', 100 + 200)  # 计算100 + 200的结果
    
    # --------------------------------------------
    # 变量
    a = 1  # 变量是用一个变量名表示,变量名必须是大小写英文、数字和_的组合,且不能用数字开头
    # 可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类型的变量,称为动态语言
    # -------------------------------------------
    # 可以使用转义字符 \ 、\n、\t等等
    # -------------------------------------------
    # raw字符串与多行字符串
    print(r'\(~_~)/ \(~_~)/');  # 我们可以在字符串前面加个前缀 r ,表示这是一个 raw 字符串,里面的字符就不需要转义了
    # 但是r'...'表示法不能表示多行字符串,也不能表示包含'和 "的字符串
    # 如果要表示多行字符串,可以用'''...'''表示
    print('''Python is created by "Guido".
    It is free and easy to learn.Let's start learn Python in imooc!''');  # 等同于'Line 1\nLine 2\nLine 3'
    
    # ---------------------------------------------------
    # Python在后来添加了对Unicode的支持,以Unicode表示的字符串用u'...'表示,比如:
    print(u'中文')
    
    #---------------------------------------------------
    #布尔类型
    a = True
    print( a and 'a=T' or 'a=F',a)
    a and 'a=T'
    #计算结果不是布尔类型,而是字符串 'a=T',这是为什么呢?
    #因为Python把0、空字符串''和None看成 False,其他数值和非空字符串都看成 True,所以:
    a and 'a=T' #计算结果是 'a=T'
    print( a and 'a=T' or 'a=F') #计算结果还是 'a=T'
    
    # 创建tuple
    # tuple是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。
    t = ('Adam', 'Lisa', 'Bart')  # 创建tuple和创建list唯一不同之处是用( )替代了[ ]
    print(t)
    # list是一种有序的集合,可以随时添加和删除其中的元素
    L = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
    # 按照索引访问list
    # 输出Bart,下标是从0开始
    print(L[4])
    # 倒序访问list
    # 输出Bart,下标是从0开始
    print(L[-2])
    
    
    # dict的特点
    # dict的第一个特点是查找速度快,无论dict有10个元素还是10万个元素,查找速度都一样(而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的,dict的缺点是占用内存大,还会浪费很多内容,list正好相反,占用内存小,但是查找速度慢。)
    # 由于dict是按 key 查找,所以,在一个dict中,key不能重复。
    # dict的第二个特点就是存储的key-value序对是没有顺序的
    # dict的第三个特点是作为 key 的元素必须不可变,Python的基本类型如字符串、整数、浮点数都是不可变的,都可以作为 key。但是list是可变的,就不能作为 key
    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59}
    # 更新dict
    d['Paul'] = 72  # 如果 key 已经存在,则赋值会用新的 value 替换掉原来的 value
    # 遍历dict
    for i in d:
        print(i,':',d[i])
     # ---------------------------------------------------
    
    
    # set 持有一系列元素,这一点和 list 很像,但是set的元素没有重复,而且是无序的,这点和 dict 的 key很像。
    # 创建
    s = set(['A', 'B', 'C'])
    # 遍历
    #更新set
    s.add(4) #元素已经存在于set中,add()不会报错,但是不会加进去了
    s.remove(4) #元素不存在set中,remove()会报错,所以remove()前需要判断。
    for name in s:
     print(name)
    

    案例(猜数字游戏):

    import random
    print("########  猜数字小游戏   #########")
    print("#  1.开始游戏  2.任意键退出游戏  #")
    print("#    注:猜错三次游戏自动退出.   #")
    print("##################################")
    put = input("请输入:")
    if put == "1":
        number = 3
        secret = random.randint(1, 100)
        while number > 0:
            temp = input("不妨猜一下我现心里想的数字是几:")
            temp2 = temp.strip()
            if temp2.isdigit():
                temp1 = int(temp2)
                if temp1 == secret:
                    exit("哼,我心里想的数是%s,你居然猜中了,猜中也没有奖励^_^ 游戏结束!"%secret)
                elif number == 1:
                    exit("没想到你那么笨三次机会都没有猜到!不妨告诉你,我心理想的数字是:%s" % (secret))
                elif temp1 > secret:
                    print("我心想的数字比%s小,还是剩%s次机会"%(temp1,number-1))
                else:
                    print("我心想的数字比%s大,还是剩%s次机会"%(temp1,number-1))
            else:
                print("Error:'%s'不是一个数字,请输入一个整数" % temp)
                number += 1
            number -= 1
    else:
        exit("退出游戏成功!")
    
    展开全文
  • python 初学基础

    千次阅读 2019-09-27 17:48:54
    程序是如何执行的? 程序的执行原理(了解程序执行的原理对后续的学习是有帮助的) ...计算机中包含有较多的硬件,但是一个程序要运行,有三个核心的硬件,分别是: ... 中央处理器,是一块超大规模的集成电路,负责处理...

    ##程序是如何执行的?
    程序的执行原理(了解程序执行的原理对后续的学习是有帮助的)
    ##计算机的三大件
    计算机中包含有较多的硬件,但是一个程序要运行,有三个核心的硬件,分别是:
    1.cpu(cpu 就是干活的,离开了 cpu 电脑就不能干活)
    中央处理器,是一块超大规模的集成电路,负责处理数据/计算
    2.内存(临时存储数据 以 G 为单位 4G 8G 16G 32G)
    临时存储数据(断电之后,数据会消失),速度快,空间小(单位价格高)
    3.硬盘(永久存储数据 以 T 为单位 1T=1024G)
    永久存储数据,速度慢,空间大(单位价格低)
    ##思考题:
    1.计算机中哪一个硬件设备负责执行程序?
    CPU
    2.内存的速度快还是硬盘的速度快?
    内存
    3.我们的程序是安装在内存中的,还是安装在硬盘中的?
    硬盘
    4.我买了一个内存条,有 500G 空间,这句话对麼?
    不对,内存条通常只有 4G/8G/16G/32G
    5.计算机关机之后,内存中的数据都会消失麼?
    是的
    ##程序执行的原理
    1.程序运行之前,程序是保存在硬盘中的
    2.当要运行一个程序的时候
    操作系统会首先让 CPU 把程序复制到内存中,CPU 执行内存中方的代码程序,程序要执行,首先要被加载到内存
    ##python 程序执行的语言
    1.操作系统首先让 CPU 把 python 解释器的程序复制到内存中
    2.python 解释器根据语法规则,从上而下让 CPU 翻译 python 程序中的代码
    3.CPU 负责执行翻译完成的的代码

    python 的解释器到底有多大?
    这里写图片描述
    **建立软链接的目的,是为了方便使用者不用记住使用的解释器是哪一个具体版本
    **
    程序的作用:处理数据
    内存的作用:存储数据

    ##python的基本错误
    1.手残党拼写错误
    vim hello.py
    print ‘hello python’
    pprint ‘say hi’
    python hello.py

    2.在脚本被里写中文,没有写中文转换语言
    vim hello.py
        #print ; 输出''里的内容到屏幕上
        print 'hello python'
        print 'say hi'
    python hello.py 
    
    改正:
    vim hello.py
        #_*_ coding:utf-8 _*_    #中文转译,这样脚本里写的中文就会被识别
        # print的作用是:输出''里的内容到屏幕上
        print 'hello python'
        print 'say hi'
    python hello.py   #执行python脚本
      hello python    #输出的内容
      say hi
    
    3.误用缩进
    vim hello.py
        print 'hello python'
            print 'say hi'
    python hello.py 
    

    这里写图片描述

    ##ipython(python的交互式模式)
    在linux的命令窗口输入ipython,就会进入python的特定窗口,在此窗口上就可以执行python命令,但是缺点是许多命令都没有,也不能用exit退出窗口,所以一般用pycharm
    这里写图片描述
    ######第一个python文件

    # _*_ coding:utf-8 _*_
    """
    file: 第一个python文件.py
    date: -07-07  11:48 PM
    author: ting
    desc:
    """
    # 这是一个单行注释
    print 'hello python'
    
    """
    这是一个多行注释/块注释
    """
    print 'good night'
    
    """
    什么时候需要注释?
    1.注释不是越多越好,对于一目了然的代码,不需要添加注释
    2.对于复杂的操作,应该在操作开始前写上若干行注释
    3.对于一般复杂的代码,应该在其行尾添加注释(为了增加可读性,注释和代码至少离开两个空格)
    4.绝对不要描述代码
    """
    

    #变量
    变量名只有在第一次出现才是定义变量(变量名再次出现,不是定义变量,而是直接使用之前定义的变量)
    ##1.变量的定义
    在 python 中,每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建
    等号(=) : 用来给变量赋值
    等号(=) 的左边是一个变量名
    等号(=) 的右边是存储在变量中的值
    变量名 = 值
    ######变量定义之后,后续就可以直接使用了
    练习1:

    # _*_ coding:utf-8 _*_
    """
    file: 变量1.py
    date: -07-08  12:09 AM
    author: ting
    desc:
    
    
    """
    # 定义一个变量记录QQ号码
    qq_number = '167837492'
    # 定义一个变量记录QQ密码
    qq_passwd = '123123'
    # 输出变量,在使用解释器执行python程序时的时候,不能直接输入变量名,要输出变量内容,使用print
    print qq_number
    print qq_passwd
    
    练习2:买东西
    <1>水果的价格是 5 元/斤
    <2>买了 7 斤橘子
    <3>计算付款金额
    
    # _*_ coding:utf-8 _*_
    """
    file: 变量2.py
    date: -07-08  12:15 AM
    author: ting
    desc:
    
    
    """
    # 定义水果的价格
    price = 5
    # 挑选水果
    weight = 7
    # 计算付款金额
    money = price * weight
    print money
    
    #变量名只有在第一次出现的时候才是定义变量
    #变量名再次出现的时候,是直接使用之前定义的变量
    
    练习3:买东西
    <1>水果的价格是 5 元/斤
    <2>买了 7斤橘子
    <3>计算付款金额
    <4>只要买橘子,就返 5 块钱
    
    # _*_ coding:utf-8 _*_
    """
    file: 变量2.py
    date: -07-08  12:15 AM
    author: ting
    desc:
    
    
    """
    # 定义水果的价格
    price = 5
    # 挑选水果
    weight = 7
    # 计算付款金额
    money = price * weight
    money = money - 5
    print money
    
    #变量名只有在第一次出现的时候才是定义变量
    #变量名再次出现的时候,是直接使用之前定义的变量
    

    ##2.变量的类型
    在内存中创建一个变量:
    1.变量的名称
    2.变量保存的数据
    3.变量存储数据的类型
    4.变量的地址
    示例:
    定义变量保存小明的个人信息
    姓名:小花
    年龄:18 岁
    性别:是女生
    身高:1.65 米
    体重:45公斤

    # _*_ coding:utf-8 _*_
    """
    file: 变量2.py
    date: -07-08  12:15 AM
    author: ting
    desc:
    
    
    """
    # 定义姓名
    name = '小花'
    # 定义性别
    sex = '女'
    # 定义年龄
     age = 18
    # 定义身高
    height = 1.65
    # 定义体重
    weight = 45 kg
    print 'name'
    print 'sex'
    

    ##3.变量的类型
    1.在 python 中定义变量是不需要指定类型(但在其他很多高级语言中都需要)
    2.数据类型可以分为数字型和非数字型
    (1)数字型
    <1>整型(int)
    <2>浮点型(float)
    <3>布尔型(bool)
    <4>真 True 非 0 数 — 非 0 即真
    (2)非数字型
    <1>字符串
    <2>列表
    <3>元组
    <4>字典
    ######使用 type 函数可以查看一个变量的类型,在使用交互式终端时,也可以知道每个变量的准确类型
    这里写图片描述
    ##4.不同类型变量之间的计算
    数字变量之间可以直接计算,在 python 中,两个数字型变量是可以直接进行算术运算的,如果变量是 bool 型,在计算时,True 对应的数字是 1,False 对应的数字是 0
    字符串变量之间使用 + 拼接字符串
    在 python 中字符串之间可以使用 + 拼接生成新的字符串字符串变量可以和整数使用 * 重复拼接相同的字符串,字符串变量和字符串之间不能进行其他计算
    ##5.变量的输入
    所谓输入,就是用代码获取用户通过键盘输入的信息
    例如:去银行取钱,在 ATM 上输入密码
    在 python 中,如果要获取用户在键盘上的输入信息,需要使用raw_input 函数
    ##6.关于函数:
    一个提前准备好的功能(别人或者自己写的代码),可以直接使用,而不用关心细节,raw_input 函数实现键盘输入,在 python 中可以使用raw_input 函数从键盘等待用户的输入,用户输入的任何内容 python 都认为是一个字符串
    练习:超市买水果增强版
    <1>收银员输入水果的价格,单位:元/斤(橘子价格不再固定)
    <2>收银员输入用户购买水果的重量,单位:斤
    <3>计算并且输出付款金额

    # _*_ coding:utf-8 _*_
    """
    file:变量3-.py
    date: 2018-07-7:59 AM
    author:ting
    desc:
    
    """
    price_str = raw_input('请输入水果的单价:')
    weight_str = raw_input('请输入水果重量:')
    # money = price_str * weight_str  #字符型的变量不能用乘号来连接
    
    
    
    ##  如果需要转换的变量太多,一个一个重新转换变量就会很麻烦,不建议这样使用
    price = float(price_str)
    weight = float(weight_str)
    money = price * weight
    print money
    
    改进
    
    # _*_ coding:utf-8 _*_
    """
    file:变量3.py
    date: 2018-07-7:38 AM
    author:ting
    desc:
        1.输入水果单价
        2.输入水果重量
        3.计算支付的总金额
    """
    # 这样的优点是节约空间,此时只需要为变量分配空间;起名字方便,不需要为中间变量起名字
    price_str = float(raw_input('请输入水果的单价:'))
    weight_str = float(raw_input('请输入水果重量:'))
    # money = price_str * weight_str  (字符型的变量不能用符号来连接)
    
    ## 如果需要转换的变量太多,一个一个重新转换变量就会很麻烦,可以直接在定义变量的时候就转换
    money = price_str * weight_str
    print money
    

    这里写图片描述

    ##7.变量的格式化输出
    (1)在 python 中可以使用 print 函数将信息输出到控制台,如果希望输出文字信息的同时,一起输出数据,就需要使用到格式化操作符
    (2)% 被称为格式化操作符,专门用于处理字符串中的格式,包含%的字符串,被称为格式化字符串
    (3)% 和不同的字符连用,不同类型的数据需要使用不同的格式化字符
    (4)格式化字符串的类型:
    %s 字符串
    %d 有符号十进制整数,%06d 表示输出的整数显示位数字,不足的地方使用
    %f 浮点数,%.02f 表示小数点后只显示两位
    0 补全
    %% 输出%
    (5)语法格式:
    print ‘格式化字符串’ % 变量 1
    print ‘格式化字符串’ % (变量 1,变量 2…)
    练习:
    1.定义字符串变量 name,输出:我的名字叫’name’,很高兴认识你

    # _*_ coding:utf-8 _*_
    """
    file:格式化输出.py
    date: 2018-07-8:27 AM
    author:ting
    desc:
    %:格式化操作符
    使用格式:
    print '格式化操作符' % 变量
    print '格式化操作符' % (变量1,变量2,...)
    %s:字符串类型
    %d: 整型
    %f:浮点类型
    """
    # 1.定义一个字符串变量 name
    # 输出格式为:我的名字叫'name',很高兴认识你
    name = '阿婷'
    print '我的名字叫%s,很高兴认识你' % name
    
    
    # 定义一个整数变量 student_num
    # 输出格式为: 我的学号为:student_num
    student_num = 5
    print '我的学号为:%06d' % student_num
    # %06d :不到6位就用0补齐
    
    
    2.定义整数变量 student_nu,输出: 我的学号是 0000013.定义小数price,weight,money 输出:橘子单价 3.60元/斤,购买了 2.50 斤,需要支付9.00元,并定义一个小数 scale,输出:数据比例是 10.00
    
    # _*_ coding:utf-8 _*_
    """
    file: 变量4.py
    date: -07-08  9:00 PM
    author: ting
    desc:
    
    
    """
    # 定义小数price weight money,输出格式为:水果的单价为‘price’,水果的重量为‘weight’,支付的总金额为‘money’
    price = 3.6
    weight = 2.5
    money = price * weight
    print '水果的单价为%.2f元/斤,水果的重量为%.2f千克,支付的总金额为%.2f' %(price,weight,money)
    # %.2f : 保留小数点后两位
    
    # 定义一个小数,输出格式为:数据比例为:num%
    scale = 0.7
    print '数据比例为%.2f%%' % (scale * 100)
    # num%的输出设置必须为 num%%,才会输出自己想要的格式
    

    这里写图片描述

    ##8.变量的命名
    1.标识符和关键字
    标识符:标识符就是程序员定义的变量名,函数名字需要有见名知义的效果,标识符可以由字母,下划线和数字组成,不能以数字开头,不能与关键字重名

    注意:python中的标识符是区分大小写的
    
    2.下面的标识符哪些是正确的,哪些不正确为什么?(自己测测吧,看自己到底有没有掌握)
    int32 		40XL(x)   $aving$(x)	printf		print(x)
    _print(x) 	this		 self			__name__	0x40L
    bool	(x)	true		big-westos(x)		2hot2ls(x)		type(x) 
    thisIs		thisisInt	R_U_Ready		Int 		True	(x)
    if(x)			do			counter-1(x)		access	
    
     关键字:关键字就是在python内部已经使用的标识符,关键字具有特殊的功能和含义,开发者不允许定义和关键字相同的名字的标示符
    
    *通过以下命令可以查看python中的关键字*
     import关键字可以导入一个工具包,在python中不同的工具包,提供有不同的工具
    

    这里写图片描述

    2.变量的命名规则
      命名规则可以被视为一种惯例,别无绝对与强制,目的是为了增加代码的识别和可读性
     (1)在定义变量时,为了保证代码格式, = 的左右两边该各保留一个空格
     (2)在python中,如果变量名需要由两个或多个单词组成,可以按照以下方式命名(python中常用)
       <1>每个单词都使用小写字母
       <2>单词与单词之间使用_下划线连接
       <3>例如:first_name,last_name....
    

    这里写图片描述

    驼峰命名法:(其他语言常用的命名法)
      当变量名是由两个或多个单词组成,还可以利用驼峰命令法来命名
    (1)小驼峰命名法
    	第一个单词以小写字母开始,后续单词的首字母大写
    	firstName lastName
    (2)大驼峰命名法
    	每一个单词的首字母都采用大写字母
    	FirstName LastName
    

    展开全文
  • Python基础入门笔记(一)

    万次阅读 多人点赞 2018-09-16 09:51:37
    有关 Python: “人生苦短,我用PythonPython的设计哲学是“优雅”、“明确”、“简单”。 一、基础(变量和字符串) 首先:Python 每个语句结束可以不写分号 ;, 如 print('hello') 打印 hello 1、变量...

    前言(认识Python)

    既然学习 Python,那么至少得了解下这门语言,知道 Python 代码执行过程吧。Python 的历史有兴趣的百度百科下就有,这个不多说了。

    1、我们先来了解下什么是解释型语言和编译型语言?

    计算机是不能够识别高级语言的,所以当我们运行一个高级语言程序的时候,就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类,第一种是编译,第二种是解释。

    编译型语言在程序执行之前,先会通过编译器对程序执行一个编译的过程,把程序转变成机器语言。运行时就不需要翻译,而直接执行就可以了。最典型的例子就是 C 语言。

    解释型语言就没有这个编译的过程,而是在程序运行的时候,通过解释器对程序逐行作出解释,然后直接运行,最典型的例子是 Ruby。

    通过以上的例子,我们可以来总结一下解释型语言和编译型语言的优缺点,因为编译型语言在程序运行之前就已经对程序做出了“翻译”,所以在运行时就少掉了“翻译”的过程,所以效率比较高。但是我们也不能一概而论,一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化,从而在效率上超过编译型语言。

    此外,随着 Java 等基于虚拟机的语言的兴起,我们又不能把语言纯粹地分成解释型和编译型这两种。用 Java 来举例,Java 首先是通过编译器编译成字节码文件,然后在运行时通过解释器给解释成机器文件。所以我们说 Java 是一种先编译后解释的语言。再换成 C#,C# 首先是通过编译器将 C# 文件编译成 IL 文件,然后在通过 CLR 将 IL 文件编译成机器文件。所以我们说 C# 是一门纯编译语言,但是 C# 是一门需要二次编译的语言。同理也可等效运用到基于 .NET 平台上的其他语言。

    2、那么 Python 到底是什么?

    其实 Python 和 Java、C# 一样,也是一门基于虚拟机的语言,我们先来从表面上简单地了解一下 Python 程序的运行过程。

    当我们在命令行中输入 python hello.py 时,其实是激活了 Python 的“解释器”,告诉“解释器”:你要开始工作了。可是在“解释”之前,其实执行的第一项工作和 Java 一样,是编译。

    熟悉 Java 的读者可以想一下我们在命令行中如何执行一个 Java 的程序:

    javac hello.java
    java hello

    只是我们在用 Eclipse 之类的 IDE 时,将这两部给融合成了一部而已。其实 Python 也一样,当我们执行python hello.py时,它也一样执行了这么一个过程,所以我们应该这样来描述 Python,Python 是一门先编译后解释的语言。

    3、简述 Python 的运行过程

    在说这个问题之前,我们先来说两个概念,PyCodeObject 和 pyc 文件。

    我们在硬盘上看到的 pyc 自然不必多说,而其实 PyCodeObject 则是 Python 编译器真正编译成的结果。我们先简单知道就可以了,继续向下看。

    当 Python 程序运行时,编译的结果则是保存在位于内存中的 PyCodeObject 中,当 Python 程序运行结束时,Python 解释器则将 PyCodeObject 写回到 pyc 文件中。

    当 Python 程序第二次运行时,首先程序会在硬盘中寻找 pyc 文件,如果找到,则直接载入,否则就重复上面的过程。

    所以我们应该这样来定位 PyCodeObject 和 pyc 文件,我们说 pyc 文件其实是 PyCodeObject 的一种持久化保存方式。

    更详细内容参考:说说Python程序的执行过程

    最后:

    • “人生苦短,我用Python”

    • Python 的设计哲学是“优雅”、“明确”、“简单”。

    一、变量和字符串

    首先:Python 每个语句结束可以不写分号 ;, 如 print('hello') 打印 hello

    1.1 变量

    有过编程基础的话,变量就不用多说了。

    变量的命名法:

    • 驼峰式命名法
    • 帕斯卡命名法

    1.2 字符串

    1、基本介绍

    单引号 ' '或者双引号 " " 都可以,再或者 ''' ''' 三个引号,其中三个引号被用于过于长段的文字或者是说明,只要是三引号不完你就可以随意换行写下文字。

    ①字符串直接能相加,如:

    str1 = 'hi'
    str2 = 'hello'
    print(str1 + str2)

    运行结果:

    hi jaybo

    ②字符串相乘,如:

    string = 'bang!'
    total = string * 3 

    打印 total 结果:

    bang!bang!bang!

    2、字符串的分片与索引

    字符串可以通过 string[x] 的方式进行索引、分片。

    字符串的分片实际可以看作是从字符串中找出来你要截取的东西,复制出来一小段你要的长度,存储在另一个地方,而不会对字符串这个源文件改动。分片获得的每个字符串可以看作是原字符串的一个副本。

    先看下面这段代码:

    name = 'My name is Mike'
    print(name[0])
    'M'
    print(name[-4])
    'M'
    print(name[11:14]) # from 11th to 14th, 14th one is excluded
    'Mik'
    print(name[11:15]) # from 11th to 15th, 15th one is excluded
    'Mike'
    print(name[5:])
    'me is Mike'
    print(name[:5])
    'My na'

    如果感到困惑话,可以对照如下表格理解和分析:

    :两边分别代表着字符串的分割从哪里开始,并到哪里结束。

    name[11:14]为例,截取的编号从第11个字符开始,到位置为14但不包含第14个字符结束。而像name[5:]这样的写法代表着从编号为5的字符到结束的字符串分片。相反,name[:5]则代表着从编号为0的字符开始到编号为5但包含第5个字符分片。可能容易搞混,可以想象成第一种是从5到最后面,程序员懒得数有多少个所以就省略地写,第二种是从最前面到5,同样懒得写0,所以就写成了[:5]

    3、字符串的方法

    • replace 方法:第一个参数表示被替代部分,第二个参数表示替代成怎样的字符串。

    • 字符串填空,如:

      city = input("write the name of city:"")
      url = "http://apistore.baidu.com/mri.../weather?citypiny={}.format(city)

    4、问题

    问题1:

    num = 1
    string = '1'
    print(num + string)

    上面代码将出错?

    解释:整数型不能和字符串直接相加。可以先把该字符串转为整数型,再相加,即 int(string)

    num = 1
    string = '1'
    print(num + int(string))

    二、函数

    举些你可能已经使用过的函数例子:

    判断数据类型:type(str) 
    字符串类型数据转为整数型:int(str)
    ...

    通过观察规律不难发现,Python 中所谓的使用函数就是把你要处理的对象放到一个名字后面的括号就可以了。简单的来说,函数就是这么使用,可以往里面塞东西得到处理结果。这样的函数在 Python 中还有这些:

    以 Python3.5 版本为例,一个有 68 个这样的函数,它们被称为内建函数。这里內建的是指这些函数为安装好了 Python 就可以使用。

    2.1 函数格式

    定义函数的格式:

    其中,defreturn关键字

    注意: 函数缩进后面的语句被称为是语句块,缩进是为了表名语句的逻辑与从属关系。缩进这个问题不能忽视,否则会导致代码无法成功运行,这里需要特别注意。

    2.2 函数参数

    ①位置参数,举例,看代码:

    def trapezoid_area(base_up, base_down, height):
        return 1/2 * (base_up + base_down) * height

    接下来我们开始调用该函数:

    trapezoid_area(1,2,3)

    不难看出,填入的参数1,2,3分别对应着参数 base_up,base_down 和 height。这种传入参数的方式被称作为位置参数。

    ②关键词参数:在函数调用的时候,将每个参数名称后面赋予一个我们想要传入的值,如调用 fun1 函数时候:fun1(a=1, b=2, c=3)

    看下图:

    • 第一行的函数参数按照反序传入,因为是关键词参数,所以并不影响函数正常运作;
    • 第二行的函数参数反序传入,但是到了第三个却变成了位置函数,遗憾的是这种方式是错误的语法,因为如果按照位置来传入,最后一个应该是参数 height 的位置。但是前面 height 已经按照名称传入了值3,所以是冲突的。
    • 第三行的函数参数正序传入,前两个是以关键字的方式传入,最后一个以位置参数传入,但是位置参数不能再关键词参数后面,所以是错误的。
    • 第四行的函数参数正序传入,前两个是以位置的方式传入,最后一个以关键字参数传入,这个函数是可以正常运行的。

    ③不定长参数

    有时我们在设计函数接口的时候,可会需要可变长的参数。也就是说,我们事先无法确定传入的参数个数。

    Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 * 。如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。例如:

    def print_user_info( name ,  age  , sex = '男' , * hobby):
        # 打印用户信息
        print('昵称:{}'.format(name) , end = ' ')
        print('年龄:{}'.format(age) , end = ' ')
        print('性别:{}'.format(sex) ,end = ' ' )
        print('爱好:{}'.format(hobby))
        return;
    
    # 调用 print_user_info 函数
    print_user_info( '小明' , 25, '男', '打篮球','打羽毛球','跑步')

    输出的结果:

    昵称:小明 年龄:25 性别:男 爱好:('打篮球', '打羽毛球', '跑步')

    通过输出的结果可以知道,* hobby 是可变参数,且 hobby 其实就是一个 tuple (元祖)。

    可变长参数也支持关键参数,没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 **,更改上面的示例如下:

    def print_user_info( name ,  age  , sex = '男' , ** hobby ):
        # 打印用户信息
        print('昵称:{}'.format(name) , end = ' ')
        print('年龄:{}'.format(age) , end = ' ')
        print('性别:{}'.format(sex) ,end = ' ' )
        print('爱好:{}'.format(hobby))
        return;
    
    # 调用 print_user_info 函数
    print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打篮球','打羽毛球','跑步'))

    输出的结果:

    昵称:小明 年龄:24 性别:男 爱好:{'hobby': ('打篮球', '打羽毛球', '跑步')}

    通过对比上面的例子和这个例子,可以知道,* hobby 是可变参数,且 hobby 其实就是一个 tuple (元祖),** hobby是关键字参数,且 hobby 就是一个 dict (字典)。

    ④ 只接受关键字参数

    关键字参数使用起来简单,不容易参数出错,那么有些时候,我们定义的函数希望某些参数强制使用关键字参数传递,这时候该怎么办呢?将强制关键字参数放到某个*参数或者单个*后面就能达到这种效果,比如:

    def print_user_info( name , *, age, sex = '男' ):
        # 打印用户信息
        print('昵称:{}'.format(name) , end = ' ')
        print('年龄:{}'.format(age) , end = ' ')
        print('性别:{}'.format(sex))
        return;
    
    # 调用 print_user_info 函数
    print_user_info( name = '小明' ,age = 25 , sex = '男' )
    
    # 这种写法会报错,因为 age ,sex 这两个参数强制使用关键字参数
    #print_user_info( '小明' , 25 , '男' )
    print_user_info('小明',age='22',sex='男')

    通过例子可以看,如果 age , sex 不适用关键字参数是会报错的。

    2.3 匿名函数

    有没有想过定义一个很短的回调函数,但又不想用 def 的形式去写一个那么长的函数,那么有没有快捷方式呢?

    ——答案是有的。

    Python 使用 lambda 来创建匿名函数,也就是不再使用 def 语句这样标准的形式定义一个函数。

    匿名函数主要有以下特点:

    • lambda 只是一个表达式,函数体比 def 简单很多。
    • lambda 的主体是一个表达式,而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
    • lambda 函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。

    基本语法:lambda [arg1 [,arg2,.....argn]]:expression

    示例:

    sum = lambda num1 , num2 : num1 + num2;
    print( sum( 1 , 2 ) )

    输出的结果: 3

    注意:尽管 lambda 表达式允许你定义简单函数,但是它的使用是有限制的。 你只能指定单个表达式,它的值就是最后的返回值。也就是说不能包含其他的语言特性了, 包括多个语句、条件表达式、迭代以及异常处理等等。

    匿名函数中,有一个特别需要注意的问题,比如,把上面的例子改一下:

    num2 = 100
    sum1 = lambda num1 : num1 + num2 ;
    
    num2 = 10000
    sum2 = lambda num1 : num1 + num2 ;
    
    print( sum1( 1 ) )
    print( sum2( 1 ) )

    你会认为输出什么呢?第一个输出是 101,第二个是 10001,结果不是的,输出的结果是这样:

    10001
    10001

    这主要在于 lambda 表达式中的 num2 是一个自由变量,在运行时绑定值,而不是定义时就绑定,这跟函数的默认值参数定义是不同的。所以建议还是遇到这种情况还是使用第一种解法。

    三、循环与判断

    3.1 布尔表达式和判断

    Python 中的布尔类型值:TrueFlase 其中,注意这两个都是首字母大写。

    但凡能够产生一个布尔值的表达式为布尔表达式

    1 > 2 # False
    1 < 2 <3 # True
    42 != '42' # True
    'Name' == 'name' # False
    'M' in 'Magic' # True
    number = 12
    number is 12 # True

    注1:不同类型的对象不能使用<><==>进行比较,却可以使用==!=

    注2:浮点类型和整数类型虽然是不同类型,但不影响比较运算。还有,不等于!= 可以写作<>

    话说,布尔类型可以比较吗?如:True > Flase,回答是可以的,TureFlase 对于计算机就像是 1 和 0 一样,所以结果是真,即True

    3.2 条件控制

    定义格式:

    用一句话该结构作用:如果…条件是成立的,就做…;反之,就做…

    所谓条件成立,指的是返回值为True的布尔表达式。

    3.3 循环

    ①for 循环

    把 for 循环所的事情概括成一句话就是:于…其中的每一个元素,做…事情。

    打印九九乘法表:

    for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(i, j, i*j), end='')
        print()

    运行结果:

    1x1=1
    2x1=2   2x2=4
    3x1=3   3x2=6   3x3=9
    4x1=4   4x2=8   4x3=12  4x4=16
    5x1=5   5x2=10  5x3=15  5x4=20  5x5=25
    6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36
    7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49
    8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64
    9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81

    ②while 循环

    总结:只要…条件一成立,就一直做…

    在循环过程中,可以使用 break 跳过循环,使用 continue 跳过该次循环。

    在 Python 的 while 循环中,可以使用 else 语句,while … else 在循环条件为 false 时执行 else 语句块。如:

    count = 0
    while count < 3:
       print (count)
       count = count + 1
    else:
       print (count)

    运行结果:

    0
    1
    2
    3

    有 while … else 语句,当然也有 for … else 语句,for 中的语句和普通的没有区别,else 中的语句会在循环正常执行完(即 for 不是通过 break 跳出而中断的)的情况下执行,while … else 也是一样。如:

    for num in range(10,20):  # 迭代 10 到 20 之间的数字
       for i in range(2,num): # 根据因子迭代
          if num%i == 0:      # 确定第一个因子
             j=num/i          # 计算第二个因子
             print ('%d 是一个合数' % num)
             break            # 跳出当前循环
       else:                  # 循环的 else 部分
          print ('%d 是一个质数' % num)

    运行结果:

    10 是一个合数
    11 是一个质数
    12 是一个合数
    13 是一个质数
    14 是一个合数
    15 是一个合数
    16 是一个合数
    17 是一个质数
    18 是一个合数
    19 是一个质数

    四、数据结构

    Python 有四种数据结构,分别是:列表、字典、元组、集合。我们先从整体上认识一下这四种数据结构:

    list = [val1,val2,val3,val4] #列表
    dict = {key1:val1,key2:val2} #字典
    tuple = (val1,val2,val3,val4) #元组
    set = {val1,val2,val3,val4} #集合

    4.1 列表(List)

    1. 列表中的每个元素都是可变的;

    2. 列表中的元素是有序的,也就是说每个元素都有一个位置;

    3. 列表中可以容纳 Python 中的任何对象。如下:

      all_in_list = [
         1, #整数
         1.0, #浮点数
         'a word', #字符串
         print(1), #函数
         True, #布尔值
         [1,2], #列表中套列表
         (1,2), #元祖
         {'key':'value'} #字典
      ]

    另外,对于数据的操作,最常见的为增删改查。在此就省略了,网上找下相应函数练习下即可。

    4.2 字典(Dict)

    1. 字典中数据必须是以键值对的形式出现的;

    2. 逻辑上讲,键是不能重复的;

    3. 字典中的键(key)是不可变的,也就是无法修改的,而值(value)是可变的,可修改的,可以是任何对象。

      下面是个例子:

      NASDAQ_code = {
         'BIDU':'Baidu',
         'SINA':'Sina',
         'YOKU':'Youku'
      }

    一个字典中键与值并不能脱离对方而存在,如果你写成了 {'BIDU':} 会引发一个语法错误:invalid syntax

    如果试着将一个可变(mutable)的元素作为 key 来构建字典,比如列表:key_test = {[]:'a Test'} ,则会报一个错:unhashable type:'list'

    同时字典中的键值不会重复,即便你这么做,相同的键值也只能出现一次:a = {'key':123,'key':123}

    增删改查操作,在此省略了。

    备注:

    • 列表中用来添加多个元素的方法为extend,在字典中添加多个元素的方法为update()
    • 字典是不能切片的,即这样的写法是错误的:chart[1:4]

    4.3 元组(Tuple)

    元组可以理解为一个稳固版的列表,因为元组是不可以修改的,因此在列表中的存在的方法均不可以使用在元组上,但是元组是可以被查看索引的,方式和列表一样。

    letters = ('a, 'b', 'c', 'd')
    letters[0]

    相关的操作找代码练习下即可。

    4.4 集合(Set)

    集合则更接近数学上集合的概念。每一个集合中是的元素是无序的、不重复的任意对象,我们可以通过集合去判断数据的从属关系,有时还可以通过集合把数据结构中重复的元素减掉。

    集合不能被切片也不能被索引,除了做集合运算之外,集合元素可以被添加还有删除:

    a_set = {1,2,3,4}
    a_set.add(5)
    a_set.discard(5)

    4.5 数据结构的一些技巧

    4.5.1 多重循环

    如下:

    代码演示:

    for a, b in zip(num, str):
        print(b, 'is', a)

    4.5.2 推导式

    列表推导式的用法很好理解,可以简单地看成两部分。如下图:

    红色虚线后面的是我们熟悉的 for 循环的表达式,而虚线前面的可以认为是我们想要放在列表中的元素。

    代码演示:

    a = []
    for i in range(1, 11):
        a.append(i)

    可以换成列表解析的方式来写:

    b = [i for in i range(1, 11)]

    列表解析式不仅方便,并且在执行效率上要远远胜过前者。

    五、类的理解

    5.1 类的介绍

    类的定义:

    class CocaCola:
        formula = ['caffeine','sugar','water','soda']

    使用 class 来定义一个类,就如同创建函数时使用的 def 定义一个函数一样简单。如上你可以看到定义了名为 CocaCola 的类,接着在缩进的地方有一个装载着列表的变量的 formula,这个在类里面定义的变量就是类的变量,而类的变量有一个专有的术语,我们称之为类的属性。

    类的属性:

    • 类变量
    • 方法

    ①类的实例化:

    coke_for_me = CocaCola()
    coke_for_you = CocaCola()

    ②类变量属性的引用:CocaCola.formulacoke_for_me.formula

    类方法的使用:

    class CocaCola:
        formula = ['caffeine','sugar','water','soda']
        def drink(self):
            print('Energy!')
    coke = CocaCola()
    coke.drink()

    结果:

    Energy!

    5.2 self

    我想很多人会有关注到这个奇怪的地方——似乎没有派上任何用场的self参数。我们来说明下原理,其实很简单,我们修改下上面的代码:

    class CocaCola:
        formula = ['caffeine','sugar','water','soda']
        def drink(coke):    # 把self改为coke
            print('Energy!')
    coke = CocaCola()
    coke.drink()

    结果:

    Energy!

    怎么样,有些头绪了吧!这个参数其实就是被创建的实例本身。也就是将一个个对象作为参数放入函数括号内,再进一步说,一旦一个类被实例化,那么我们其实可以使用和与我们使用函数相似的方式:

    coke = CocaCola
    coke.drink() == CocaCola.drink(coke) #左右两边的写法完全一致

    被实例化的对象会被编译器默默地传入后面方法的括号中,作为第一个参数。上面两个方法是一样的,但我们更多地会写成前面那种形式。其实self这个参数名称是可以随意修改的(编译器并不会因此而报错)。

    和函数一样,类的方法也能有属于自己的参数,如下:

    class CocaCola:
        formula = ['caffeine','sugar','water','soda']
        def drink(self,how_much):
    
        if how_much == 'a sip':
            print('Cool~')
        elif how_much == 'whole bottle’:
            print('Headache!')
    ice_coke = CocaCola()
    ice_coke.drink('a sip')

    结果:

    Cool~

    5.3 魔术方法

    Python 的类中存在一些方法,被称为「魔术方法」,_init_()就是其中之一。

    class CocaCola():
        formula = ['caffeine','sugar','water','soda']
        def __init__(self):
            self.local_logo = '可口可乐'
        def drink(self): 
            print('Energy!')
    coke = CocaCola()
    print(coke.local_logo)

    作用:在创建实例之前,它做了很多事情。说直白点,意味着即使你在创建实例的时候不去引用 init_() 方法,其中的语句也会先被自动的执行。这给类的使用提供了极大的灵活性。

    class CocaCola:
        formula = ['caffeine','sugar','water','soda']
        def __init__(self,logo_name):
            self.local_logo = logo_name
        def drink(self):
            print('Energy!')
    coke = CocaCola('ݢݗݢԔ')
    coke.local_logo
    >>> 可口可乐

    有过面向对象编程经验很好理解了,也就是很多面向对象语言中的「构造函数」。

    5.4 类的继承

    如下代码:

    class CaffeineFree(CocaCola):
        caffeine = 0
        ingredients = [
            'High Fructose Corn Syrup',
            'Carbonated Water',
            'Phosphoric Acid',
            'Natural Flavors',
            'Caramel Color',
        ]
    coke_a = CaffeineFree('Cocacola-FREE')
    coke_a.drink()

    表示 CaffeineFree 继承了 CocaCola 类。

    类中的变量和方法可以被子类继承,但如需有特殊的改动也可以进行覆盖。

    Q1:类属性如果被重新赋值,是否会影响到类属性的引用?

    class TestA():
        attr = 1
    obj_a = TestA()
    
    TestA.attr = 24
    print(obj_a.attr)
    
    >>> 结果:24

    A1:会影响。

    Q2:实例属性如果被重新赋值,是否会影响到类属性的引用?

    class TestA:
        attr = 1
    obj_a = TestA()
    obj_b = TestA()
    
    obj_a.attr = 42
    print(obj_b.attr)
    
    >>> 结果:1

    A2:不会影响。

    Q3:类属性实例属性具有相同的名称,那么.后面引用的将会是什么?

    class TestA():
        attr =1
        def __init__(self):
            self.attr = 24
    
    obj_a = TestA()
    
    print(obj_a.attr)
    
    >>> 结果:24

    A3:类属性赋值后的值。

    总结:如图所示,Python 中属性的引用机制是自外而内的,当你创建了一个实例之后,准备开始引用属性,这时候编译器会先搜索该实例是否拥有该属性,如果有,则引用;如果没有,将搜索这个实例所属的类是否有这个属性,如果有,则引用,没有那就只能报错了。

    六、使用第三方库

    6.1 安装自己的库

    我们一般使用 pip 来进行第三方库的安装,那么自己的库要怎么安装呢?当然可以把自己的库提交到 pip 上,但是还要添加一定量的代码和必要的文件才行,在这里我们使用一个更简单的方法:
    1. 找到你的 Python 安装目录,找到下面的 site-packages 文件夹;
    2. 记住你的文件名,因为它将作为引用时的名称,然后将你写的 py 文件放进去。

    这个文件夹应该有你所安装的所有第三方库。如果你并不清楚你的安装路径,可以尝试使用如下方式搞清楚它究竟在哪里:

    import sys
    print(sys.path)

    打印出来的会是一个列表,列表中的第四个将是你的库安装路径所在,因此你也可以直接这么做:

    import sys
    print(sys.path[3])

    6.2 安装第三方库

    令人惊叹的第三方库

    如果用手机来比喻编程语言,那么 Python 是一款智能机。正如含量的手机应用出现在 iOS、Android 平台上,同样有各种各样的第三方库为 Python 开发者提供了极大的便利。

    当你想要搭建网站时,可以选择功能全面的 Django、轻量的 Flask 等 web 框架;当你想写一个小游戏的时候,可以使用 PyGame 框架;当你想做一个 爬虫时,可以使用 Scrapy 框架;当你想做数据统计分析时,可以使用 Pandas 数据框架……这么多丰富的资源可以帮助我们高效快捷地做到想做的事,就不需要再重复造轮子了。

    那么如何根据自己的需求找到相应的库呢?可以到 awesome-python.com 这个网站上按照分类去寻找,上面收录了比较全的第三方库。比如想要找爬出方面的库时,查看 Web Crawling 这个分类,就能看到相应的第三方库的网站与简介,可以进入库的网站查看更详细的介绍,并确认这个库支持的是 Python 2 还是 Python 3,不过绝大多数常用库已经都支持了这两者。另外也可以直接通过搜索引擎寻找。

    安装第三方库方式:

    ①最简单的方式:在 PyCharm 中安装

    1. 在 PyCharm 的菜单中选择:File –> Default Setting
    2. 搜索 project interpreter,选择当前 python 版本,点击“+”添加库
    3. 输入库的名称,勾选,并点击 Install Package

    在安装成功后, PyCharm 会有成功提示。也可以在 project interpreter 这个界面中查看安装了哪些库,点“-”号就可以卸载不再需要的库。

    ②最直接的方式:在终端/命令行中安装

    PyPI(Python Package Index)是 Python 官方的第三方库的仓库,PyPI 推荐使用 pip 包管理器来下载第三方库。

    1. 安装 pip

      在 Python 3.4 之后,安装好 Python 环境就可以直接支持 pip,你可以在终端/命令行里输入这句检查一下:pip --version (前提电脑 path 路径已经配置好了),如果显示 pip 版本,就说明 pip 已经成功安装了;如果发现没有安装,则根据不同系统如下方式安装:

    2. 使用 pip 安装库

      在安装好了 pip 之后,以后安装库,只需要在命令行里面输入:pip3 install PackageName(注:如果你想要安装到 Python 2 中,需要把 pip3 换成 pip)。补充:

      如果你安装了 Python 2 和 3 两种版本,可能会遇到安装目录的问题,可以换成:python3 -m pip install PackageName (注:如果你想安装到 Python2 中,需要把 Python3 换成 Python)

      如果遇到权限问题,可以输入:sudo pip install PackageName

      安装成功之后会提示:Successfully insyalled PackageName

      一些常用的 pip 指令:

      
      # pip 使用格式:pip <command> [options] package_name
      
      
      pip install package_name==1.9.2 # 安装指定版本的包
      pip install --upgrade package_name  # 更新指定的包
      pip uninstall package_name  # 卸载指定的包
      pip show package_name   # 查看所安装包的详细信息
      pip list    # 查看所有安装的包
      pip --help  # 查看帮助

    补充:如果下载很慢,可以考虑更改 pip 下载源。国内镜像有:

    # 国内常用的镜像
    http://pypi.douban.com/simple/            # 豆瓣
    http://mirrors.aliyun.com/pypi/simple/    # 阿里
    https://pypi.tuna.tsinghua.edu.cn/simple  # 清华
    http://pypi.mirrors.ustc.edu.cn/simple/   # 中国科学技术大学
    http://pypi.hustunique.com/simple/        # 华中理工大学

    更改方法:

    1. 临时使用,添加 -i--index 参数:pip install -i http://pypi.douban.com/simple/ flask
    2. Linux下永久生效的配置方法

      cd $HOME  
      mkdir .pip  
      cd .pip
      sudo vim pip.conf  
      
      
      # 在里面添加,trusted-host 选项为了避免麻烦是必须的,否则使用的时候会提示不受信任  
      
      [global]
      index-url=https://pypi.tuna.tsinghua.edu.cn/simple
      
      [install]
      trusted-host=pypi.tuna.tsinghua.edu.cn 
      disable-pip-version-check=true
      timeout = 6000 
    3. Windows 下永久生效的配置方法

      
      # a、进入如下目录(没有此目录或文件就自己创建下)
      
      C:\Users\username\AppData\Local\pip
      或
      C:\Users\username\pip
      
      
      # b、创建 “pip.ini” 文件(注意:以UTF-8 无BOM格式编码),添加如下内容
      
      [global]
      index-url=https://pypi.tuna.tsinghua.edu.cn/simple
      
      [install]
      trusted-host=pypi.tuna.tsinghua.edu.cn 
      disable-pip-version-check=true
      timeout = 6000 

    ③最原始的方式:手动安装

    进入 pypi.python.org,搜索你要安装的库的名字,这时候有 3 种可能:

    1. 第一种是 exe 文件,这种最方便,下载满足你的电脑系统和 Python 环境的对应的 exe,再一路点击 next 就可以安装。
    2. 第二种是 .whl 类文件,好处在于可以自动安装依赖的包。

      1. 到命令行输入pip3 install whell 等待执行完成,不能报错(Python 2 中要换成 pip)
      2. 从资源管理器中确认你下载的 .whl 类文件的路径,然后在命令行继续输入:cd C:\download,此处需要改为你的路径,路径的含义是文件所在的文件夹,不包含这个文件名字本身,然后再命令行继续输入:pip3 install xxx.whlxxx.whl 是你下载的文件的完整文件名。
    3. 第三种是源码,大概都是 ziptar.ziptar.bz2 格式的压缩包,这个方法要求用户已经安装了这个包所依赖的其他包。例如 pandas 依赖于 numpy,你如果不安装 numpy,这个方法是无法成功安装 pandas 的。

      1. 解压包,进入解压好的文件夹,通常会看见一个 setup.py 的文件,从资源管理器中确认你下载的文件的路径,打开命令行,输入:cd C:\download 此处需要改为你的路径,路径的含义是文件所在的文件夹,不包含这个文件名字本身
      2. 然后在命令行中继续输入:python3 setup.py install 这个命令,就能把这个第三方库安装到系统里,也就是你的 Python路径,windows 大概是在 C:\Python3.5\Lib\site-packages

      注:想要卸库的时候,找到 Python 路径,进入 site-packages 文件夹,在里面删掉库文件就可以了。

    本文内容大部分来源:

    展开全文
  • 1、为什么学习Python? 人生苦短?人间不值得?想想自己的初心吧! 2、通过什么途径学习的Python? 官网、网上视频、学习网站、论坛、大牛的辅导 3、Python和Java、PHP、C、C#、C++等其他语言的对比? (1)、python...
        

    图片描述
    1、为什么学习Python?

    人生苦短?人间不值得?想想自己的初心吧!

    2、通过什么途径学习的Python?

    官网、网上视频、学习网站、论坛、大牛的辅导

    3、Python和Java、PHP、C、C#、C++等其他语言的对比?

    (1)、python代码,简介,明确,优雅,简单易懂
    (2)、开发效率高
    (3)、可扩展性强

    4、简述解释型和编译型编程语言?

    解释型:在执行程序时,计算机才一条一条的将代码解释成机器语言给计算机来执行
    编译型:是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样计算机运行该程序时可以直接以机器语言来运行此程序,运行速度很快。

    5、Python解释器种类以及特点?

    Cpython,IPython,Jpython,pypy,Ironpython

    Python是一门解释器语言,代码想运行,必须通过解释器执行,Python存在多种解释器,分别基于不同语言开发,每个解释器有不同的特点,但都能正常运行Python代码,以下是常用的五种Python解释器:

    CPython:当 从Python官方网站下载并安装好Python2.7后,就直接获得了一个官方版本的解

        释器:Cpython,这个解释器是用C语言开发的,所以叫 CPython,在命名行下运行python,
        就是启动CPython解释器,CPython是使用最广的Python解释器。

    IPython:IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方

        式上有所增强,但是执行Python代码的功能和CPython是完全一样的,好比很多国产浏览器
        虽然外观不同,但内核其实是调用了IE。

    PyPy:PyPy是另一个Python解释器,它的目标是执行速度,PyPy采用JIT技术,

        对Python代进行动态编译,所以可以显著提高
                 Python代码的执行速度。
                 

    Jython:Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。
    IronPython:IronPython和Jython类似,只不过IronPython是运行在微软.Net平台上的Python解释器,

        可以直接把Python代码编译成.Net的字节码。
        
    

    在Python的解释器中,使用广泛的是CPython,对于Python的编译,除了可以采用以上解释器
    进行编译外,技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码,十分的方便!

    6、位和字节的关系?

    一个字节=8位

    7、b、B、KB、MB、GB 的关系?

    1B(字节) = 8b(位)
    1KB = 1024B
    1MB = 1024KB
    1GB = 1024MB

    8、请至少列举5个 PEP8 规范

    (1)、缩进:每一级4个缩进。连续跨行应该使用圆括号或大括号或者使用悬挂缩进。
    (2)、代码长度约束

    一行列数:PEP8 规定最大为79列,如果拼接url很容易超限
    一个函数:不可以超过30行;直观来讲就是完整显示一个函数一个屏幕就够了,不需要上下拖动
    一个类:不要超过200行代码,不要超过10个方法
    一个模块:不要超过500行

    (3)、import

    不要在一句import中引用多个库

    (4)、命名规范
    (5)、注释

    总体原则,错误的注释不如没有注释。所以当一段代码发生变化时,第一件事就是要修改注释!
    

    9、通过代码实现如下转换:

    答案: 二进制转换成十进制:v = “0b1111011”

            print(int('0b1111011',2))
            十进制转换成二进制:v = 18
            print(bin(18))
            八进制转换成十进制:v = “011”
            print(int('011',8))
            十进制转换成八进制:v = 30
            print(oct(30))
            十六进制转换成十进制:v = “0x12”
            print(int('0x12',16))
            十进制转换成十六进制:v = 87
            print(hex(87))
            

    10、请编写一个函数实现将IP地址转换成一个整数。

    如 10.3.9.12 转换规则为:

        10            00001010
         3            00000011
         9            00001001
        12            00001100
        

    再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 00001100 = ?

    答案:

    def func(x):
        lis = x.strip().split('.')
        li = [bin(int(i)) for i in lis]
        li2 = [i.replace('0b',(10-len(i))*'0') for i in li]
        return int(''.join(li2),2)
    ret = func('10.3.9.12')
    print(ret)
    

    11、python递归的最大层数?

    一般计算机默认的最大递归深度在1000左右,python最大递归深度一般在4000左右,跟计算
    机的性能有关系,这个数不是一个定数,可通过一下方式测试

    import sys
    print(sys.getrecursionlimit())
    print(sys.setrecursionlimit(10000))
    

    12、求结果:

    v1 = 1 or 3 -------------->1
    v2 = 1 and 3-------------->3
    v3 = 0 and 2 and 1-------->0
    v4 = 0 and 2 or 1--------->1
    v5 = 0 and 2 or 1 or 4---->1
    v6 = 0 or Flase and 1----->False

    13、ascii、unicode、utf-8、gbk 区别?

    ASCII码:使用一个字节编码,所以它的范围基本是只有英文字母、数字和一些特殊符号 ,只有256个字符。
    Unicode:能够表示全世界所有的字节
    GBK:是只用来编码汉字的,GBK全称《汉字内码扩展规范》,使用双字节编码。
    UTF-8:是一种针对Unicode的可变长度字符编码,又称万国码。

    14、字节码和机器码的区别?

    机器码:是电脑CPU直接读取运行的机器指令,运行速度最快,但是非常晦涩难懂
    字节码:是一种中间状态(中间码)的二进制代码(文件)。需要直译器转译后才能成为机器码。

    15、三元运算规则以及应用场景?

    规则:为真时的结果 if 判定条件 else 为假时的结果
    `应用场景:在赋值变量的时候,可以直接加判断,然后赋值`

    16、列举 Python2和Python3的区别?

    1、默认编码:2-->ascii,3-->utf-8
    2、print的区别:python2中print是一个语句,不论想输出什么,直接放到print关键字后面即可。python3里,print()是一个函数,

    像其他函数一样,print()需要你将要输出的东西作为参数传给它。

    3、input的区别:

    python2有两个全局函数,用在命令行请求用户输入。第一个叫input(),它等待用户输入一个python表达式(然后返回结果)。
    第二个叫做raw_input(),用户输入什么他就返回什么。python3 通过input替代了他们。

    4、字符串:python2中有两种字符串类型:Unicode字符串和非Unicode字符串。Python3中只有一种类型:Unicode字符串。
    5、xrange()

    python2里,有两种方法获得一定范围内的数字:range(),返回一个列表,还有xrange(),返回一个迭代器。
    python3 里,range()返回迭代器,xrange()不再存在。
    
    

    17、用一行代码实现数值交换:

    a = 1
    b = 2

    答案:a = 1

    b = 2
    a,b = b,a
    

    18、Python3和Python2中 int 和 long的区别?

    python2有非浮点数准备的int和long类型。int类型最大
    值不能超过sys.maxint,而且这个最大值是平台相关的。
    可以通过在数字的末尾附上一个L来定义长整型,显然,它比int类型表示的数字范围更大。在python3里,
    只有一种整数类型int,大多数情况下,和python2中的长整型类似。

    19、xrange和range的区别?

    python2里,有两种方法获得一定范围内的数字:range(),返回一个列表,还有xrange(),返回一个迭代器。
    python3 里,range()返回迭代器,xrange()不再存在。

    20、文件操作时:xreadlines和readlines的区别?

    readlines返回一个list,xreadlines方法返回一个生成器

    21、列举布尔值为False的常见值?

    0, [] , () , {} , '' , False , None

    22、字符串、列表、元组、字典每个常用的5个方法?

    字符串:repleace,strip,split,reverse,upper,lower,join.....
    列表:append,pop,insert,remove,sort,count,index.....
    元组:index,count,__len__(),__dir__()
    字典:get,keys,values,pop,popitems,clear,update,items.....

    23、lambda表达式格式以及应用场景?

    表达式格式:lambda后面跟一个或多个参数,紧跟一个冒号,以后是一个表达式。冒号前是参数,冒号后是返回值。例如:lambda x : 2x
    应用场景:经常与一些内置函数相结合使用,比如说map(),filter(),sorted(),reduce()等

    24、pass的作用?

    1、空语句 do nothing
    2、保证格式完整
    3、保证语义完整

    25、arg和*kwarg作用?

    万能参数,解决了函数参数不固定的问题
    *arg:会把位置参数转化为tuple
    **kwarg:会把关键字参数转化为dict

    26、is和==的区别?

    is:判断内存地址是否相等
    ==:判断数值是否相等

    27、简述Python的深浅拷贝以及应用场景?

    copy():浅copy,浅拷贝指仅仅拷贝数据集合的第一层数据
    deepcopy():深copy,深拷贝指拷贝数据集合的所有层

    28、Python垃圾回收机制?

    python采用的是引用计数机制为主,标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略
    计数机制

    Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上,还可以通过“标记-清除”
    解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。

    标记-清除:

    标记-清除的出现打破了循环引用,也就是它只关注那些可能会产生循环引用的对象
    缺点:该机制所带来的额外操作和需要回收的内存块成正比。

    隔代回收

    原理:将系统中的所有内存块根据其存活时间划分为不同的集合,每一个集合就成为一个“代”,
    垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说,活得越长的对象,就越不可能是垃圾,
    就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间:通常是利用几次垃圾收集动作来衡量,
    如果一个对象经过的垃圾收集次数越多,可以得出:该对象存活时间就越长。
    

    29、python的可变类型和不可变类型?

    不可变类型(数字、字符串、元组、不可变集合)
    可变类型(列表、字典、可变集合)

    30、求结果:

    v = dict.fromkeys(['k1','k2'],[])
    v['k1'].append(666)
    print(v)
    v['k1'] = 777
    print(v)

    答案:{'k1':[666],'k2':[666]}
         {'k1':777,'k2':[666]}
    解析:formkeys()默认参数为可变数据类型时有坑
    

    31、求结果:

    def num():
        return [lambda x: i*x for i in range(4)]
    print([m(2) for m in num()])
    
    答案:[6, 6, 6, 6]
    解析: 问题的本质在与python中的属性查找规则,LEGB(local,enclousing,global,bulitin),
        在上面的例子中,i就是在闭包作用域(enclousing),而Python的闭包是 迟绑定 ,
        这意味着闭包中用到的变量的值,是在内部函数被调用时查询得到的
        所以:[lambda x: i*x for i in range(4)]打印出来是含有四个内存地址的列表,每个内存地址中的i
            在在本内存中都没有被定义,而是通过闭包作用域中的i值,当for循环执行结束后,i的值等于3,所以
            再执行[m(2) for m in num()]时,每个内存地址中的i值等于3,当x等于2时,打印出来的结果都是6,
            从而得到结果[6, 6, 6, 6]。
            

    32、列举常见的内置函数?

    map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,str,list,tuple,dict,range,next,hash,help,id.....

    33、filter、map、reduce的作用?

    filter(function,iterable)过滤函数
    map(function,iterable)循环函数
    reduce(function, iterable)累积函数

    34、一行代码实现9*9乘法表。

    lis = ['%s%s=%s'%(i,j,ij) for i in range(1,10) for j in range(i,10)]

    35、如何安装第三方模块?以及用过哪些第三方模块?

    pip3 imstall 模块名
    django,Matplotlib,Tornado,PyGame

    36、至少列举8个常用模块都有那些?

    os,sys,time,random,re,hashlib,logging,json,pickle....

    37、re的match和search区别?

    match:从字符串的开头位置匹配,必须以此为开头
    search:从开头开始查,找到符合的就返回结果

    38、什么是正则的贪婪匹配?

    正则表达式一般趋向于最大长度匹配

    39、求结果:

    a. [ i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1]
    b. ( i % 2 for i in range(10) )===>返回一个生成器的内存地址

    40、求结果:

    a. 1 or 2 =========>1
    b. 1 and 2 ========>2
    c. 1 < (2==2)======>false
    d. 1 < 2 == 2======>ture

    41、def func(a,b=[]) 这种写法有什么坑?

    def func(a,b=[]):

     b.append(a)
     print(b)

    函数的第二个默认参数是一个list,当第一次执行的时候实例化了一个list,
    第二次执行还是用第一次执行的时候实例化的地址存储,以后每次实例化都是

    42、如何实现 "1,2,3" 变成 ['1','2','3'] ?

    a = "1,2,3"
    li = a.split(',')

    43、如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

    li = ['1','2','3']
    lis = list(map(lambda x:int(x) li))

    44、比较: a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别?

    a = [1,2,3]正常的列表
    b = [(1),(2),(3)] 虽然列表的每个元素加上了括号,但是当括号内只有一个元素并且没有逗号时,其数据类型是元素本身的数据类型
    b = [(1,),(2,),(3,)]列表中的元素类型都是元组类型

    45、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

    li = [x*x for x in range(1,11)]

    46、一行代码实现删除列表中重复的值 ?

    li = [1, 1, 1, 23, 3, 4, 4]
    new_li = list(set(li))
    new_li.sort(key=li.index)

    47、如何在函数中设置一个全局变量 ?

    使用python的内置语法 globals 全局变量

    48、logging模块的作用?以及应用场景?

    logging模块的作用:
    1、程序调试
    2、了解软件程序运行情况,是否正常
    3、软件程序运行故障分析与问题定位
    应用场景:网站的运维工作,程序实时监控

    49、请用代码简答实现stack 。

    def Stack(object):

    def __init__(self):
        self.stack = []
    
    def push(self,value):
        # 进栈
        self.stack.append(value)
    
    def pop(self):
        # 出栈
        if self.stack:
            self.stack.pop()
        else:
            raise LookupError('stack is empty!')
    
    def is_empty(self):
        # 查看stack是否为空
        reture bool(self.stack)
    
    def top(self):
        # 取出stack中最新的值
        return self.stack[-1]
        

    50、常用字符串格式化哪几种?

    1、%s %d
    2、format格式化输出
    3、print(f'内容{变量名}')

    51、简述 生成器、迭代器、可迭代对象 以及应用场景?

    生成器:在 Python 中,一边循环一边计算的机制,称为 生成器(generator),

        通过next()取值,两种表现形式1、将列表生成式的[]改为()2、含有yield关键字的函数
        应用场景:优化代码,节省内存

    迭代器:是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法
    可迭代对象:只要实现了__iter__方法的对象就是可迭代对象

    52、用Python实现一个二分查找的函数。

    lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]

    def two_find(x, lis, start=0, end=None):

    if end == None:end = len(lis) - 1
    num = (end - start) // 2 + start
    if end > start:
        if lis[num] > x:
            return two_find(x, lis, start=start, end=num)
        elif lis[num] < x:
            return two_find(x, lis, start=num + 1, end=end)
        elif lis[num] == x:
            return num
    elif lis[end] == x:return end
    else:return None
    

    print(two_find(17, lis))

    53、谈谈你对闭包的理解?

    在一个外函数中定义了一个内函数,内函数里运用了外函数的临时变量,并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
    一般情况下,在我们认知当中,如果一个函数结束,函数的内部所有东西都会释放掉,还给内存,局部变量都会消失。
    但是闭包是一种特殊情况,如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到,就把这个临时变量绑定给了内部函数,然后自己再结束。

    54、os和sys模块的作用?

    os模块负责程序与操作系统的交互,提供了访问操作系统底层的接口;
    sys模块负责程序与python解释器的交互,提供了一系列的函数和变量,用于操控python的运行时环境。

    55、如何生成一个随机数?

    import random
    def rdm(n):

    lis = []
    for i in range(n):
        n = random.randint(1,9)
        lis.append(str(n))
    s = ''.join(lis)
    return int(s)
    

    56、如何使用python删除一个文件?

    import os
    os.remove(r'path')

    57、谈谈你对面向对象的理解?

    面向对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,
    不存在的也可以创造出来。对象是特征和技能的结合,其中特征和技能分别对应对象的数据属性和方法属性。
    优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。
    缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,
    面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果。
    应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方。

    58、Python面向对象中的继承有什么特点?

    1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。
    2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。

    区别于在类中调用普通函数时并不需要带上self参数

    3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。

    (先在本类中查找调用的方法,找不到才去基类中找)。
    

    59、面向对象深度优先和广度优先是什么?

    Python的类可以继承多个类,那么其寻找类方法的方式有两种:

    当类是经典类时(主要在python2版本中的没有主动继承object的类),多继承情况下,会按照深度优先方式查找
    当类是新式类时(python3版本中的所有类和python2中主动继承object的类),多继承情况下,会按照广度优先方式查找
    简单点说就是:经典类是纵向查找,新式类是横向查找
    

    60、面向对象中super的作用?

    1、super在面向对象继承类中代指父类,书写方法super(类名,self).属性或者方法或super().属性或者方法
    2、super方法可以增加类之间调用的灵活性,当父类名发生变化时不必修改
    3、super方法在类的多继承时可以简化代码,避免代码冗余
    4、super机制里可以保证公共父类仅被执行一次,执行的顺序遵循MRO,广度优先查询方法

    61、是否使用过functools中的函数?其作用是什么?

    functools用于高阶函数:指那些作用于函数或者返回其他函数的函数。通常情况下,只要是
    可以被当做函数调用的对象就是这个模块的目标。

    62、列举面向对象中带双下划线的特殊方法,如:new、init

    __new__:构造方法,创建一个对象,实例化时第一个被执行,返回一个创建好的对象及__init__(self)的self,

    只有继承了object的类才会有这个方法

    __init__:初始化方法,__init__在__new__的基础上完成一些其它初始化的动作,__init__没有返回值

    63、如何判断是函数还是方法?

    函数和方法都封装了一些独立的功能,如果在类中定义的函数那就是方法(对象或者类名点方法名调用),

    否则就是函数(函数名()直接调用)
    

    64、静态方法和类方法区别?

    静态方法:是既不是用类中的属性又不使用对象中的属性,由类或者对象调用的方法,依赖python装饰器@staticmethod来实现
    类方法:只使用类中的静态变量,一般都是由类调用,依赖python装饰器@classmethod来实现

    65、列举面向对象中的特殊成员以及应用场景?

    __call__:对象的构造方法,对象加上(),可以触发这个类的__call__方法。
    __len__:内置函数的len函数是依赖类中的__len__方法
    __eq__:判断值是否相等的时候依赖__eq__方法
    __hash__:判断hash值是否相等的时候依赖__hash__方法(拓展:set的去重机制其实就是根据__hash__和__eq__方法实现的)
    __str__:和str() print() %s 都是息息相关的,返回值一定是字符串类型
    __repr__:和 repr() %r都是息息相关的,在没有__str__方法时,__repr__可以完全取代__str__。
    del 析构方法,对应着一个对象的删除之前执行的内容

    66、1、2、3、4、5 能组成多少个互不相同且无重复的三位数
    count = 0
    for i in range(1,6):

    for j in range(1,6):
        for k in range(1,6):
            if (i != j) and (i != k) and (j != k):
                count += 1
                if count % 6:
                    print(f'{i}{j}{k}', end='|')
                else:
                    print(f'{i}{j}{k}')

    print(count)

    67、什么是反射?以及应用场景?

    定义:通过用字符串数据类型的变量名来访问这个变量的值,在python面向对象中的反射,通过字符串的形式操作对象相关的属性或方法.
    应用场景:用于处理通过用户输入,文件读取,或者网络传输所得到的字符串形式的指令来完成对应的操作

    68、metaclass作用?以及应用场景?

    metaclass,直译为元类,简单的解释就是:当我们定义了类以后,就可以根据这个类创建出实例,
    所以:先定义类,然后创建实例。但是如果我们想创建出类呢?那就必须根据metaclass创建出类,
    所以:先定义metaclass,然后创建类。换句话说,你可以把类看成是metaclass创建出来的“实例”

    69、用尽量多的方法实现单例模式。

    1、基于__new__()方法

    class Person:
        def __new__(cls, *args, **kwargs):
            if not hasattr(cls,cls._instance):
                # cls._instance = object.__new__(cls)
                cls._instance = super().__new__(cls)
            return cls._instance

    2、基于模块导入方式,现在一个py文件中写好一个类,实例化一个对象。以后用这个类直接导入这个模块就是单例模式。
    3、基于装饰器方法实现

    def singleton(cls, *args, **kwargs):
        instance_dic = {}
    
        def inner(*args, **kwargs):
            if cls not in instance_dic:
                instance_dic['cls'] = cls(*args, **kwargs)
            return instance_dic['cls']
    
        return inner
    
    @singleton
    class Person:
        pass
        

    70、装饰器的写法以及应用场景。

    装饰器的写法:

    def wrapper(func):
        def inner(*args,**kwargs):
            '被装饰之前的操作'
            ret = func(*args,**kwargs)
            '被装饰之后的操作'
            return ret
        return inner
    

    装饰器的应用场景:

    比如注册登录、插入日志,性能测试,事务处理,缓存等等场景
    

    71、异常处理写法以及如何主动跑出异常(应用场景)

    异常处理的常规写法:

        try:
            执行的主体函数
        except Exception as e:
            print(str(e))
    主动抛出异常:
        raise TypeError('出现了不可思议的异常')#TypeError可以是任意的错误类型
        

    72、什么是面向对象的mro

    MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法,
    它是基于算法来实现的,不同的算法实现的MRO的顺序不同
    

    73、isinstance作用以及应用场景?

    isinstance作用是来判断一个对象是否是一个已知的类型

    74、写代码并实现:

    Given an array of integers, return indices of the two numbers such that they add up to a specific target.
    You may assume that each input would have exactly one solution, and you may not use the same element twice.
    Example:

          Given nums = [2, 7, 11, 15], target = 9,
           Because nums[0] + nums[1] = 2 + 7 = 9,
           return [0, 1]
           

    代码实现

    def func(li,target):

    try:
        for i in range(0,len(li)):
            num = target-li[i]
            if num in li:
                return [i,li.index(num)]
    except:print('li类型为数组类型,内的元素需是整型,target也为整型,请检查')
    else:return None
    

    75、json序列化时,可以处理的数据类型有哪些?如何定制支持datetime类型?

    1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null
    2、定制支持datetime类型
    --------------------------官方文档的memo-----------------------------------------------

        >>> import json
        >>> class ComplexEncoder(json.JSONEncoder):
        ...     def default(self, obj):
        ...         if isinstance(obj, complex):
        ...             return [obj.real, obj.imag]
        ...         return json.JSONEncoder.default(self, obj)
        ...
        >>> dumps(2 + 1j, cls=ComplexEncoder)
            '[2.0, 1.0]'
        >>> ComplexEncoder().encode(2 + 1j)
            '[2.0, 1.0]'
        >>> list(ComplexEncoder().iterencode(2 + 1j))
            ['[', '2.0', ', ', '1.0', ']']

    import json
    import datetime
    ret = datetime.datetime.now()
    class CJsonEncoder(json.JSONEncoder):
        def default(self, obj):
            if isinstance(obj, datetime.date):
                return obj.strftime('%Y-%m-%d %H:%M:%S')
            else:
                return json.JSONEncoder.default(self, obj)
    
    print(json.dumps(ret,cls=CJsonEncoder))
    

    76、json序列化时,默认遇到中文会转换成unicode,如果想要保留中文怎么办?

    在序列化是将json.dumps中的默认参数ensure_ascii改为False就可以保留中文了
    json.dumps(obj,ensure_ascii=False)

    77、什么是断言?应用场景?

    assert 条件,'自定义错误提示(可有可无)' 例:assert 1 == 0,'这是一个低级的错误'
    合约式设计是断言的经典应用,在一个正确的程序里,所有的前置条件和后置条件都将得到处理。
    78、使用代码实现查看列举目录下的所有文件。
    方法一:递归处理

    import os
    url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\前段学习'
    
    def check_file(url,li = []):
        if os.path.isdir(url):
            file_list = os.listdir(url)
            for ret in file_list:
                base_url = os.path.join(url,ret)
                if os.path.isfile(base_url):
                    li.append(ret)
                else: check_file(base_url)
            return li
        else:return os.path.basename(url)
    

    方法二:堆栈的思想处理

    import os
    url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python基础'
    
    lis = [url]
    while lis:
        url = lis.pop()
        ret_list = os.listdir(url)
        for name in ret_list:
            abs_path = os.path.join(url,name)
            if os.path.isdir(abs_path):
                lis.append(abs_path)
            else:print(name)
            

    79、简述 yield和yield from关键字。

    yield 是一个类似 return 的关键字,只是这个函数返回的是个生成器当你调用这个函数的时候,
    函数内部的代码并不立马执行 ,这个函数只是返回一个生成器对象,当你使用for进行迭代的时候,
    函数中的代码才会执行

    yield from 的主要功能是打开双向通道,把最外层的调用方与最内层的子生成器连接起来,
    这样二者可以直接发送和产出值,还可以直接传入异常,而不用在位于中间的协程中添加大量处理异常的样板代码。
    有了这个结构,协程可以通过以前不可能的方式委托职责。

    80、代码实现六位随机验证码

    import random
    s = ''
    for i in range(6):
        num = random.randint(0,9)
        alpha1 = chr(random.randint(65,90))
        alpha2 = chr(random.randint(97,122))
        ret = random.choice([num,alpha1,alpha2])
        s += str(ret)
    print(s)
    

    81、代码实现随机发红包功能

    import random
    def red_packge(money,num):
        li = random.sample(range(1,money*100),num-1)
        li.extend([0,money*100])
        li.sort()
        return [(li[index+1]-li[index])/100 for index in range(num)]
    
    ret = red_packge(100,10)
    print(ret)
    
    --------------------------生成器版-------------------------------------------
    import random
    def red_packge(money,num):
        li = random.sample(range(1,money*100),num-1)
        li.extend([0,money*100])
        li.sort()
        for index in range(num):
            yield (li[index+1]-li[index])/100
    
    ret = red_packge(100,10)
    print(ret)
    
    

    82、请尽可能列举python列表的成员方法,并给出列表操作的答案:

    (1) a=[1, 2, 3, 4, 5], a[::2]=? a[-2:]=?
             a[::2]=[1,3,5], 
             a[-2:] = [4,5]
    
    (2)一行代码实现对列表a中的偶数位置的元素进行加3后求和?
            sum([i+3 for i in a[::2]])
    
    (3)将列表a的元素顺序打乱,再对a进行排序得到列表b,然后把a和b按元素顺序构造一个字典d。
           import  random
           random.shuffle(a)
           b=a.sort()
           d={}
           for i in range(len(a)):d[a[i]] = b[i]

    83、Python自省

    自省就是面向对象的语言所写的程序在运行时,就能知道对象的类型。也就是程序运行时能够获得对象的类型。比如type(),dir(),getattr(),hasattr(),isinstance()。

    84、Python是如何进行内存管理的?

    从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制

    一、对象的引用计数机制

    Python内部使用引用计数,来保持追踪内存中的对象,所有对象都有引用计数。
    引用计数增加的情况:
    1,一个对象分配一个新名称
    2,将其放入一个容器中(如列表、元组或字典)
    引用计数减少的情况:
    1,使用del语句对对象别名显示的销毁
    2,引用超出作用域或被重新赋值
    sys.getrefcount( )函数可以获得对象的当前引用计数
    多数情况下,引用计数比你猜测得要大得多。对于不可变数据(如数字和字符串),解释器会在程序的不同部分共享内存,以便节约内存。

    二、垃圾回收

    1,当一个对象的引用计数归零时,它将被垃圾收集机制处理掉。
    2,当两个对象a和b相互引用时,del语句可以减少a和b的引用计数,并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用,因此引用计数不会归零,对象也不会销毁。(从而导致内存泄露)。为解决这一问题,解释器会定期执行一个循环检测器,搜索不可访问对象的循环并删除它们。

    三、内存池机制

    Python提供了对内存的垃圾收集机制,但是它将不用的内存放到内存池而不是返回给操作系统。
    1,Pymalloc机制。为了加速Python的执行效率,Python引入了一个内存池机制,用于管理对小块内存的申请和释放。
    2,Python中所有小于256个字节的对象都使用pymalloc实现的分配器,而大的对象则使用系统的malloc。
    3,对于Python对象,如整数,浮点数和List,都有其独立的私有内存池,对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数,用于缓存这些整数的内存就不能再分配给浮点数。

    85、介绍一下except的用法和作用?

    try…except…except…else…
    -- 执行try下的语句,如果引发异常,则执行过程会跳到except语句。对每个except分支顺序尝试执行,如果引发的异常与except中的异常组匹配,执行相应的语句。如果所有的except都不匹配,则异常会传递到下一个调用本代码的最高层try代码中。
    -- try下的语句正常执行,则执行else块代码。如果发生异常,就不会执行
    -- 如果存在finally语句,最后总是会执行。

    86、如何用Python来进行查询和替换一个文本字符串?

    可以使用re模块中的sub()函数或者subn()函数来进行查询和替换,比replace的功能更强大!!!
    格式:sub(replacement, string[,count=0])(replacement是被替换成的文本,string是需要被替换的文本,count是一个可选参数,指最大被替换的数量)

    import re
    p=re.compile("blue|white|red")
    print(p.sub('colour','blue socks and red shoes'))
    print(p.sub('colour','blue socks and red shoes',count=1))

    subn()方法执行的效果跟sub()一样,不过它会返回一个二维数组,包括替换后的新的字符串和总共替换的数量

    87、有没有一个工具可以帮助查找python的bug和进行静态的代码分析?

    PyChecker是一个python代码的静态分析工具,它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告
    Pylint是另外一个工具可以进行codingstandard检查

    很多时候跟着书和不系统的视频网站学习,会发现没有目标,学了很多却不知道自己到底能够做出什么成绩。要有一个清晰的职业学习规划,学习过程中会遇到很多问题,你可以到我们的 python学习 -q-u-n- 【 784758214 】,基础,进阶。好友都会在里面交流,分享一些学习的方法和需要注意的小细节,每天也会准时讲一些项目实战案例。

    点击:加入

    展开全文
  • 转行零基础该如何学Python?这些一定要明白!

    万次阅读 多人点赞 2018-07-21 22:09:26
    转行零基础Python编程开发难度大吗?从哪学起?近期很多小伙伴问我,如果自己转行学习Python,完全0基础能否学会呢?Python的难度到底有多大?今天,小编就来为大家详细解读一下这个问题。 学习Python难吗? ...
  • 【详细】Python基础(一)

    千次阅读 多人点赞 2020-09-15 00:46:53
    Python基础语法2.1 基本语法 前言 人生苦短,我用Python 1. Python环境的搭建 解释器和开发集成环境pycharm的安装还是比较简单的。   1.1 python解释器的安装   (1)到官网下载python解释器 下载地址:...
  • python基础语法总结

    万次阅读 多人点赞 2018-04-27 14:36:42
    本文参考廖雪峰的python教程输入和输出输出用print()在括号中加上字符串,就可以向屏幕上输出指定的文字。比如输出'hello, world',用代码实现如下:&gt;&gt;&gt; print('hello, world') print()函数也...
  • Python基础教程(一)

    万次阅读 多人点赞 2019-04-23 00:42:29
    Python基础教程 一、简介 Python的历史和为什么学习Python这里就不在赘述了。处于工作原因,对Python要进行深入的学习和研究,这里主要针对的就是Python具有的丰富和强大的库。 Python目前有两个版本,Python2和...
  • python:类基础

    万次阅读 多人点赞 2020-09-17 20:38:34
    2、在python中,所有数据类型都被视为对象,也可以自定义对象。自定义对象数据类型就是面向对象中类的概念 面向对象术语简介 1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象...
  • 一张图认识Python(附基本语法总结)

    万次阅读 多人点赞 2018-08-23 16:46:25
    Python基础语法总结: 1.Python标识符 在 Python 里,标识符有字母、数字、下划线组成。 在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。 Python 中的标识符是区分大小写的。 ...
  • Python基础教程》---值得读几遍的Python入门书

    万次阅读 多人点赞 2018-08-04 12:21:36
    Python基础教程》看了三遍。第一遍囫囵吞枣、尝试写代码;第二遍重温,同步看《Python学习手册》、《Python Cookbook》,部分细节(如正则表达式)对照另两本书一起看,敲代码;第三遍仔细看了一遍,花了一个多月...
  • Python 基础(一):入门必备知识

    万次阅读 多人点赞 2020-06-14 10:51:19
    Python 入门必备知识,你都掌握了吗?
  • Python基础知识点梳理

    万次阅读 多人点赞 2020-02-04 20:23:57
    本文主要介绍一些平时经常会用到的python基础知识点,用于加深印象。python的详细语法介绍可以查看官方编程手册,也有一些在线网站对python语法进行了比较全面的介绍,比如菜鸟教程: python3 教程|菜鸟教程 本文...
  • Python基础教程,Python入门教程(非常详细)

    万次阅读 多人点赞 2019-06-25 13:26:47
    第1章 Python编程基础 1.编程语言是什么 2.编译型语言和解释型语言 3.Python是什么 4.Python具有哪些特点(优点和缺点) 5.学Python,不需要有编程基础! 6.学Python能干什么 7.Python 2.x和Python 3.x,初学...
  • python基础学习的书籍

    万次阅读 2019-04-05 10:22:56
    分享几本python基础学习的书籍给大家 《Python编程:从入门到实践》 《Python编程:从入门到实践》 书籍详情链接 内容简介:本书是一本针对所有层次的Python 读者而作的Python 入门书。全书分两部分:第一部分介绍...
  • 廖雪峰python教程——第一章 Python基础

    万次阅读 多人点赞 2016-12-06 14:59:13
    第一章 Python基础 一、数据类型和变量 Python的数据类型包括整数、浮点数、字符串、布尔值、空值、变量、常量等。其中整数可以表示任意大小的整数;空值是Python里一个特殊的值,用None表示。 对于变量:Python...
  • Python基础知识归纳

    千次阅读 多人点赞 2019-05-18 10:38:18
    Python 基础教程 Python 基础教程 Python 简介 Python 环境搭建 Python 中文编码 Python 基础语法 Python 变量类型 Python 运算符 Python 条件语句 Python 循环语句 Python While 循环语句 Python for ...
  • Python基础教程视频集锦

    千次阅读 2019-02-28 16:35:21
    大多数Python 开发者从事以下三种开发:Web(38%)、通用开发(22%)、科学类开发...想找Python基础教程视频集锦?看这里! 千锋Python基础教程:http://pan.baidu.com/s/1qYTZiNE Python课程教学高手晋级视频总目录:h...
  • 这里推荐这门python编程入门基础教程,适合零基础的同学学习! python软件工程师都学什么? 自学Python,看视频学的更快、更透彻一些,给你个课程大纲! 阶段一:Python开发基础 Python全栈开发与人工智能之Python开发...
  • python基础视频下载地址大全

    千次阅读 2019-02-28 16:49:34
    在千锋贴吧有同学说,想看看Python基础视频。那么,现在就是福利时间。 Python从入门到精通,点击领取↓↓↓ python基础视频教程:http://pan.baidu.com/s/1qYTZiNE python高手晋级视频教程:http://pan.bai...
1 2 3 4 5 ... 20
收藏数 538,489
精华内容 215,395
关键字:

python基础