一、概述
简史
  • 1989:Guido van Rossum
  • 2008:python3.0 诞生
  • 2014:宣布2.7支持到2020
  • 2017:AI元年,Python崛起
环境
anaconda + pycharm
Python3.6

二、变量类型
  • 数字类型 Number
  • 字符串类型 str
  • 列表 list
  • 元组 tuple
  • 字典 Dictionary
  • 集合 set
  • 数字类型 Number
  • 数字类型没有大小限制
  • 整数
  • 浮点数
  • 复数 complex
  • 布尔值(布尔值可以跟数字直接操作)
字符串类型 str
表示方法:
  • 单引号
  • 双引号
  • 三引号(三个单引号或者三个双引号)
  • 单双引号交错使用
  • 格式化(利用百分号(%)) %d: 整数 %s: 字符串
print("%s新手"%"Python")
利用format函数
s = "{}新手".format("Python")

None
表示什么都没有
如果函数没有返回值,可以返回 None
用来占位


三、内置数据结构
1.list(列表)
    # 1, 创建空列表
    l1 = []

    # 2. 创建带值的列表
    l2 = [100]

    # 3. 创建列表,带多个值
    l3 = [2,3,1,4,6,4,6]

    # 4. 使用list()
    l4 = list()
列表常用操作
访问
使用下标操作(索引)
列表的位置是从0开始
分片操作
对列表进行任意一段的截取
l[:]
注意截取的范围,包含左边的下标值,不包含右边的下标值
标值可以为空,如果不写,左边下标值默认为0, 右边下标值为最大数加一,即表示截取到最后一个数据
分片可以控制增长幅度,默认增长幅度为1
# 打印从下标1开始的数字,每次隔一个
    print(l[1:6:2])
下标可以超出范围,超出后不在考虑多余下标内容
下标值,增长幅度可以为负数,为负数,表明顺序是从右往左,规定: 数组最后一个数字的下标是-1
分片操作是生成一个新的list
  • del: 删除命令
  • 使用加号链接两个列表
  • 使用乘号操作列表(相当于把n个列表接在一起)
  • 成员资格运算
  • 链表的遍历

        # for in list
        a = [1,2,3,4,5]

        # 挨个打印a里边的元素
        for i in a:
            print(i)
            
        # range
        # in 后面的变量要求是可以可迭代的内容
        for i in range(1,10):
            print(i)
            
        # 双层列表循环
        # a 为嵌套列表,或者叫双层列表
        a = [["one", 1], ["two", 2], ["three", 3] ]

        for k,v in a:
            print(k, "--", v)
            
        # 双层列表循环变异
        # a 为嵌套列表,或者叫双层列表
        a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
        # 这个例子说明,k,v,w的个数应该跟解包出来的变量个数一致
        for k,v,w in a:
            print(k, "--", v, "--",w)
  • 列表内涵: list content
    # for 创建
        a = ['a''b''c']
        # 用list a创建一个list b
        # 下面代码的含义是,对于所有a中的元素,逐个放入新列表b中
        b = [i for i in a]
        
        # 对a中所有元素乘以10,生成一个新list
        a = [1,2,3,4,5]
        # 用list a创建一个list b
        # 下面代码的含义是,对于所有a中的元素,逐个放入新列表b中
        b = [i*10 for i in a]
        
        # 还可以过滤原来list中的内容病放入新列表
        # 比如原有列表a, 需要把所有a中的偶数生成新的列表b
        a = [x for x in range(1,35)] #生成从1到34的一个列表
        # 把a中所有偶数生成一个新的列表 b
        b = [m for m in a if m % 2 == 0]
        
        # 列表生成式可以嵌套
        # 由两个列表a,b
        a = [i for i in range(1,4)] # 生成list a

        b = [i for i in range(100,400) if i % 100 == 0]

        # 列表生成是可以嵌套,此时等于两个for循环嵌套
        c = [  m+n for m in a for n in b]
        # 上面代码跟下面代码等价
        for m in a:
            for n in b:
                print(m+n, end="  ")

        # 嵌套的列表生城市也可以用条件表达式
        c = [  m+n for m in a for n in b if m+n < 250]
  • 关于列表的常用函数
    len:求列表长度
    a = [x for x in range(1,100)]
    print(len(a))
    max:求列表中的最大值
    b = ['man''film''python']
    print(max(b))
    min
    list:将其他格式的数据转换成list
    # 把range产生的内容转换成list
    print(list(range(12, 19)))
    append 插入一个内容, 在末尾追加
    a = [ i for i in range(1,5)]
    a.append(100)
    insert: 制定位置插入
    # insert(index, data), 插入位置是index前面
    a.insert(3, 666)
    del 删除
    pop,从对位拿出一个元素,即把最后一个元素取出来
    last_ele = a.pop()
    remove:在列表中删除指定的值的元素(如果被删除的值没在list中,则报错)
    clear:清空
    reverse:翻转列表内容,原地翻转
    a = [ 1,2,3,4,5]
    a.reverse()
    extend:扩展列表,两个列表,把一个直接拼接到后一个上
    a = [ 1,2,3,4,5]
    b = [6,7,8,9,10]
    a.extend(b)
    count:查找列表中指定值或元素的个数
    a_len = a.count(8)
    copy: 拷贝,此函数是浅拷贝
    b = a.copy()
2.tuple(元组)
    # 创建空元组
    t = ()

    # 创建一个只有一个值的元组
    t = (1,)
    t = 1,

    # 创建多个值的元组
    t = (1,2,3,4,5)
    t =  1,2,3,4,5

    # 使用其他结构创建
    l = [1,2,3,4,5]
    t = tuple(l)
元组的特性
  • 是序列表,有序
  • 元组数据值可以访问,不能修改
  • 元组数据可以是任意类型
  • list所有特性,除了可修改外,元组都具有
  • 元组的函数
len: 获取元组的长度
max, min:最大最小值
count: 计算制定数据出现的次数
index:求制定元素在元组中的索引位置
3.set(集合)
    # 集合的定义
    s = set()
    # 此时,大括号内一定要有值,否则定义出的是一个dict
    s = {1,2,3,4,5,6,7}
    
    # 如果只是用大括号定义,则定义的是一个dict类型
    d = {}
集合的特征
  • 集合内数据无序,即无法使用索引和分片
  • 集合内部数据元素具有唯一性,可以用来排除重复数据
  • 集合内的数据,str, int, float, tuple,冰冻集合等,即内部只能放置可哈希数据
  • 集合序列操作
  • 成员检测(in,not in)
  • 遍历
        # for 循环
        s = {4,5,"i"}

        for i in s:
            print(i, end=" ")
            
        # 带有元组的集合遍历
        s = {(1,2,3), ("just""for""fun"), (4,5,6)}

        for k,m,n in s:
            print(k, "--", m, "--", n)
        
        for k in s:
            print(k)
  • 集合的内涵
        # 普通集合内涵
        # 以下集合在初始化后自动过滤掉重复元素
        s = {23,223,545,3,1,2,3,4,3,2,3,1,2,4,3}

        # 普通集合内涵
        ss = {i for i in s}
        
        # 带条件的集合内涵
        sss = {i for i in s if i % 2 == 0}
        
        # 多循环的集合内涵
        s1 = {1,2,3,4}
        s2 = {"just""for""fun"}

        s = {m*n for m in s2 for n in s1}

        s = {m*n for m in s2 for n in s1 if n ==2}
  • 集合函数
    len, max, min
    set:生成一个集合
    add:向集合内添加元素
    clear
    copy
    remove:移除制定的值,直接改变原有值,如果要删除的值不存在,报错
    discard:移除集合中指定的值,跟 remove 一样,但是入股要删除的话,不报错
    pop 随机移除一个元素
函数
  • intersection: 交集
  • difference:差集
  • union: 并集
  • issubset: 检查一个集合是否为另一个子集
  • issuperset: 检查一个集合是否为另一个超集
数学操作
    s1 = {1,2,3,4,5,6}
    s2 = {5,6,7,8,9}

    s_1 = s1 - s2
    s_2 = s1 + s2

frozen set
:冰冻集合
不可以进行任何修改的集合
    # 创建
    s = frozenset()

4.dict(字典)
没有顺序的组合数据,数据以键值对形式出现
    # 字典的创建
    # 创建空字典1
    d = {}

    # 创建空字典2
    d = dict()

    # 创建有值的字典, 每一组数据用冒号隔开, 每一对键值对用逗号隔开
    d = {"one":1, "two":2, "three":3}

    # 用dict创建有内容字典1
    d = dict({"one":1, "two":2, "three":3})

    # 用dict创建有内容字典2
    # 利用关键字参数
    d = dict(one=1, two=2, three=3)

    # 
    d = dict( [("one",1), ("two",2), ("three",3)])

字典的特征
  • 字典是序列类型,但是是无序序列,所以没有分片和索引
  • 字典中的数据每个都有键值对组成,即kv对
  • key: 必须是可哈希的值,比如int,string,float,tuple, 但是,list,set,dict 不行
  • value: 任何值
字典常见操作
    # 访问数据
    d = {"one":1, "two":2, "three":3}
    # 注意访问格式
    # 中括号内是键值
    print(d["one"])

    d["one"] = "eins"

    # 删除某个操作
    # 使用del操作
    del d["one"]
    
    # 成员检测, in, not in
    # 成员检测检测的是key内容
    d = {"one":1, "two":2, "three":3}

    if 2 in d:
        print("value")
    
    if "two" in d:
        print("key")
    
    if ("two",2) in d:
        print("kv")
        
    # 按key来使用for循环
    d = {"one":1, "two":2, "three":3}
    # 使用for循环,直接按key值访问
    for k in d:
        print(k,  d[k])
    
    # 上述代码可以改写成如下
    for k in d.keys():
        print(k,  d[k])
    
    # 只访问字典的值
    for v in d.values():
        print(v)
    
    # 注意以下特殊用法
    for k,v in d.items():
        print(k,'--',v)

字典生成式
     d = {"one":1, "two":2, "three":3}

    # 常规字典生成式
    dd = {k:v for k,v in d.items()}

    # 加限制条件的字典生成式
    dd = {k:v for k,v in d.items() if v % 2 == 0}

字典相关函数
len, max, min, dict
str(字典): 返回字典的字符串格式
clear: 清空字典
items: 返回字典的键值对组成的元组格式
keys:返回字典的键组成的一个结构
values: 同理,一个可迭代的结构
get: 根据制定键返回相应的值
    d = {"one":1, "two":2, "three":3}
    print(d.get("on333"))

    # get默认值是None,可以设置
    print(d.get("one", 100))
: 使用指定的序列作为键,使用一个值作为字典的所有的键的值
     l = ["eins""zwei""drei"]
    # 注意fromkeys两个参数的类型
    # 注意fromkeys的调用主体
    d = dict.fromkeys(l, "oops")



四、表达式
运算符
  • 算数运算符
  • 比较或者关系运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算
  • 成员运算
  • 身份运算符
  • 算数运算符
  • 加 +
  • 减 -
  • 乘 *
  • 除 /
  • 取余 %
  • 取商(地板除) //
  • 幂运算 **
    ??Python 没有自增自减运算符
比较运算符
  • ==
  • !=
  • >
  • <
  • >=
  • <=
比较的结果是布尔值(True/False)
赋值运算符
  • =
  • += (-=, ×=, /=, //=, %=, **=)
逻辑运算符
  • and 逻辑与
  • or 逻辑或
  • not 逻辑非
结果如果是0则为False, 否则为True
短路
Python 中没有异或运算
成员运算符
用来检测某一个变量是否是另一个变量的成员
  • in
  • not in
身份运算符
  • is: 用来检测两个变量是否是同一个变量
  • is not: 两个变量不是同一个变量
运算符的优先级
括号具有最高优先级
  **  指数 (最高优先级)
  ~ + -   按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
  * / %  //    乘,除,取模和取整除
  + - 加法减法
  \>> <<   右移,左移运算符
  &   位 'AND'
  ^ | 位运算符
  <= < > >=   比较运算符
  <> == !=    等于运算符
  = %= /=  //= -= += *= **=    赋值运算符
  is is not   身份运算符
  in not in   成员运算符
  not or and  逻辑运算符


五、程序结构
顺序
分支
基本语法
    # 表达式后面的冒号不能少
    # 用缩进来表示同一个代码块
    if 条件表达式:
          语句1
          语句2
          语句3
          ..
双向分支
    # if 和 else 一个层级,其余语句一个层级
    if 条件表达式:
      语句1
      语句2
      
      else:
      语句1
      语句2
      
多路分支
      if  条件表达式:
      语句1
      .
      elif 条件表达式:
      语句1
      
      elif 条件表达式:
      语句1
      

      ..
      else:
      语句1
      .
Python 没有 switch-case 语句
循环
for 循环
    for 变量 in 序列:
      语句1
      语句2
      

range
生成一个数字序列
范围:[m,n)
    # 打印 1~10
    for i in range(1,11):
        print(i) 
for-else
当for循环结束的时候,会执行else语句
else语句可选
while 循环
      while 条件表达式:
      语句块

      #另外一种表达方法
      while  条件表达式:
      语句块1
      else
      语句块2
循环之break,continue,pass
break: 无条件结束整个循环,简称循环猝死
continue:无条件结束本次循环,从新进入下一轮循环
pass:表示略过,通常用于站位,没有跳过功能



六、函数
def关键字
代码缩进
    # 定义
    def func():
        print("这是一个函数")
    # 调用
    func()
函数的参数和返回值
参数: 负责给函数传递一些必要的数据或者信息
  • 形参(形式参数): 在函数定义的时候用到的参数没有具体值,只是一个占位的符号,成为形参
  • 实参(实际参数): 在调用函数的时候输入的值
返回值: 函数的执行结果
  • 使用 return 关键字
  • 如果没有 return ,默认返回一个 None
  • 函数一旦执行 return 语句,则无条件返回,即结束函数的执行
    # return语句的基本使用
    # 函数打完招呼后返回一句话
    def hello(person):
        print("{0}, 你肿么咧".format(person))
        print("Sir, 你不理额额就走咧")
    
    return "我已经跟{0}打招呼了,{1}不理我".format(person, person)
  
    p = "明月"
    rst = hello(p)
    print(rst)
    # 定义一个函数,打印一行九九乘法表
    def printLine(row):
        for col in range(1, row+1):
            # print函数默认任务打印完毕后换行
            print( row * col, end=" ")
        print("")
    # 九九乘法表
    # version 2.0
    for row in range(1,10):
        printLine(row)
参数详解
  • 参数分类
  • 普通参数
  • 默认参数
  • 关键字参数
  • 收集参数
  • 普通参数
参见上例
定义的时候直接定义变量名
调用的时候直接把变量或者值放入指定位置
     def 函数名(参数1, 参数2,.):
        函数体

    # 调用
    函数名(value1, value2,.)
默认参数
形参带有默认值
调用的时候,如果没有对相应形参赋值,则使用默认值
    def func_name(p1=v1, p2=v2.):
        func_block

    #调用1
    func_name()

    # 调用2
    value1 = 100
    value2 = 200
    func_name(value1,value2)
关键字参数
    def func(p1=v1, p2=v2..):
          func_body

    # 调用函数:
      func(p1=value1, p2=value2.)
收集参数
把没有位置,不能和定义时的参数位置相对应的参数,放入一个特定的数据结构中
      def func(*args):
          func_body
      # 按照list使用方式访问args得到传入的参数
      # 调用:
      func(p1, p2, p3, ..)
收集参数混合调用的顺序问题
收集参数,关键字参数,普通参数可以混合使用
使用规则就是,普通参数和关键字参数优先
定义的时候一般找普通参数,关键字参数,收集参数 tuple,收集参数 dict
返回值
函数和过程的区别
  • 有无返回值
  • 需要用return显示返回内容,
  • 如果没有返回,则默认返回None
递归函数
python对递归深度有限制,超过限制报错
    # 斐波那契额数列
    # 一列数字,第一个值是1, 第二个也是1, 从第三个开始,每一个数字的值等于前两个数字出现的值的和
    # 数学公式为: f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)
    # 例如: 1,1,2,3,5,8,13.。。。。。。。。

    # n表示求第n个数子的斐波那契数列的值
    def fib(n):
        if n == 1:
            return 1
    
        if n == 2:
            return 1
    
        return fib(n-1) + fib(n-2)

    print(fib(3))
    print(fib(10))

汉诺塔问题
规则:
每次移动一个盘子
任何时候大盘子在下面,小盘子在上面
方法:
n=1: 直接把A上的一个盘子移动到C上, A->C
n=2:
把小盘子从A放到B上, A->B
把大盘子从A放到C上, A->C
把小盘子从B放到C上, B->C
n=3:
把A上的两个盘子,通过C移动到B上去, 调用递归实现
把A上剩下的一个最大盘子移动到C上, A->C
把B上两个盘子,借助于A,挪到C上去, 调用递归
n = n:
把A上的n-1个盘子,借助于C,移动到B上去,调用递归
把A上的最大盘子,也是唯一一个,移动到C上,A->C
把B上n-1个盘子,借助于A,移动到C上, 调用递归
     def hano(n, a, b, c):
        '''
        汉诺塔的递归实现
        n:代表几个盘子
        a:代表第一个塔,开始的塔
        b:代表第二个塔,中间过渡的塔
        c:代表第三个塔, 目标塔
        
'''
        if n == 1:
            print(a, "-->", c)
            return None
        '''
    
        if n == 2:
            print(a, "-->", b)
            print(a, "-->", c)
            print(b, "-->", c)
            return None
        
'''
        # 把n-1个盘子,从a塔借助于c塔,挪到b塔上去
        hano(n-1, a, c, b)
        print(a, "-->", c)
        # 把n-1个盘子,从b塔,借助于a塔,挪到c塔上去
        hano(n-1,b, a, c)
    a = "A"
    b = "B"
    c = "C"

    n = 1
    hano(n, a, b, c)
    
    n = 2
    hano(n, a, b, c)
    
    n = 3
    hano(n, a, b, c)
查找函数帮助文档
help 函数
help(print)
使用__doc__
    def stu(name, age):
        '''
        这是文档的文字内容
        :param name: 表示学生的姓名
        :param age: 表示学生的年龄
        :return: 此函数没有返回值
        
'''
        pass
        
    print(help(stu))
    print("*" * 20)
    print(stu.__doc__)



七、变量作用域
分类:按照作用域分类
  • 全局(global): 在函数外部定义
  • 局部(local):在函数内部定义
LEGB原则
  • L(Local)局部作用域
  • E(Enclosing function locale)外部嵌套函数作用域
  • G(Global module)函数定义所在??樽饔糜?/li>
  • B(Buildin): python内置魔抗的作用域
提升局部变量为全局变量(使用global)
    def fun():
        global b1
        b1 = 100
        print(b1)
        print("I am in fun")
        # b2的作用范围是fun
        b2 = 99
        print(b2)
    
    fun()
    print(b1)

globals, locals函数
可以通过globals和locals显示出局部变量和全局变量
    # globals 和 locals
    # globals 和 locals 叫做内建函数
    a = 1
    b = 2

    def fun(c,d):
        e = 111
        print("Locals={0}".format(locals()))
        print("Globals={0}".format(globals()))
    
    fun(100, 200)

eval()函数
把一个字符串当成一个表达式来执行, 返回表达式执行后的结果
eval(string_code, globals=None, locals=None)
exec()函数
跟eval功能类似, 但是,不返回结果
exec(string_code, globals=None, locals=None)
posted on 2018-06-03 19:24 Ying-er 阅读(558) 评论(0)  编辑  收藏 所属分类: Python 、

只有注册用户登录后才能发表评论。


网站导航:
 
83| 111| 239| 541| 60| 28| 627| 729| 289| 30|