python基础

杨超越管用啊
223 阅读8分钟

序列

  • py有6个序列的内置类型
  • 最常见的是列表和元组
  • 序列都可以进行的操作
    • 索引
    • 切片
    • 加
    • 乘
    • 检查成员
  • py已经内置确定序列的长度以及确定最大和最小元素的方法

列表list

  • 可变，使用方括号[]表示。

    list = ['Google', 'Test', 1997, 2000];

  • 访问list

    • 可以使用下标索引来访问list中的值，从0开始。

  • 更新list

    • 以索引对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项

      #!/usr/bin/python3
list = ['Google', 'Test', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2]
# result
# 第三个元素为 :  1997
# 更新后的第三个元素为 :  2001

  • 删除list

    • 使用 del 语句来删除列表的的元素

      #!/usr/bin/python3
list = ['Google', 'Test', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
# result
# 原始列表 :  ['Google', 'Test', 1997, 2000]
# 删除第三个元素 :  ['Google', 'Test', 2000]

  • 列表截取/拼接/函数/方法

    • 截取

    • Python 表达式结果描述
      List[2]'Taobao'读取第三个元素
      List[-2]'Test'从右侧开始读取倒数第二个元素: count from the right
      List[1:]['Test', 'Taobao']输出从第二个元素开始后的所有元素

      函数

      序号函数
      1len(list) 列表元素个数
      2max(list) 返回列表元素最大值
      3min(list) 返回列表元素最小值
      4list(seq) 将元组转换为列表

    • 方法

      序号方法
      1list.append(obj) 在列表末尾添加新的对象
      2list.count(obj) 统计某个元素在列表中出现的次数
      3list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
      4list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
      5list.insert(index, obj) 将对象插入列表
      6list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
      7list.remove(obj) 移除列表中某个值的第一个匹配项
      8list.reverse() 反向列表中元素
      9list.sort( key=None, reverse=False) 对原列表进行排序
      10list.clear() 清空列表
      11list.copy() 复制列表

元组tuple

  • 不可变，使用小括号()表示。

    tuple = ('Google', 'Test', 1997, 2000);

  • 访问

    • 元组也是一个序列
    • 可以使用下标索引来访问元组中的值，从0开始。

  • 修改

    • 元组中的元素值是不允许修改的，可以使用+连接创建新元组

  • 删除

    • 元组中元素值是不允许删除的，可以用del删除整个元组

  • 运算符

    • 可以使用+/*进行运算，组合和复制，运算后会生成新的元组

字典dict

  • 可变，键/值对存储，但是键不可变。

    dict = {key1 : value1, key2 : value2 }

  • 键，如字符串/数字/元组。

  • 访问

    • 把相应的键放在方括号中

      dict = {'Name': 'Test', 'Age': 7, 'Class': 'First'} 
print ("dict['Name']: ", dict['Name'])

  • 修改

    • 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

  • 删除

    • 使用del删除单一元素

      dict = {'Name': 'Test', 'Age': 7, 'Class': 'First'} 
del dict['Name'] 
# dict = {'Age': 7, 'Class': 'First'}

    • 使用clear()方法清空，字典还存在

    • 使用del dict之后，字典不再存在

  • 特性

    • 不允许同一个键出现2次。否则会记住后一个值。
    • 键必须不可变。可以用数字/字符串/元组，列表不可以！

  • 内置函数

    • len(dict)计算字典元素个数，即键的总数
    • str(dict)输出字典，也可打印的字符串表示
    • type(variable)返回输入的变量类型

  • 内置方法

    • radiansdict.clear() 删除字典内所有元素

    • radiansdict.copy() 返回一个字典的浅复制

    • radiansdict.fromkeys()

      创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

    • radiansdict.get(key,default=None)

      返回指定键的值，如果值不在字典中返回default的值

    • key in dict

      如果键在字典dict里返回true，否则返回false

    • radiansdict.items()

      以列表返回可遍历的（键，值）元组数组

    • radiansdict.keys()

      返回一个迭代器，可以使用list()来转换为列表

    • radiansdict.setdefault(key,default=None)

      和get类似，但如果键不存在于字典中，将会添加键并将值设为default

    • radiansdict.update(dict2)

      把字典dict2的键/值对更新到dict里

    • radiansdict.values()

      返回一个迭代器，可以使用 list() 来转换为列表

    • pop(key[,default])

      删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

    • popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。

集合set

  • 集合是一个无序的不重复的元素序列

    • 可以使用大括号{}或者set()函数来创建集合。

    • 创建一个空集合必须用set()，因为{}用来创建一个空字典。

      parame = {value01,value02,...}
或者
set(value)

  • 添加元素

    • s.add(x)

      将元素x添加到集合s中，如果元素已存在，不进行操作

    • s.update(x)

      可以添加元素，且参数可以是列表，元组，字典等

      x可以有多个

  • 移除元素

    • s.remove(x)
    • 随机移除元素，s.pop()
      • 交互模式下，删除第一个

  • 计算集合的个数

    • len(s)

  • 清空集合

    • s.clear()

  • 判断元素在集合中是否存在

    • x in s

  • 集合内置方法

    方法描述
    add()为集合添加元素
    clear()移除集合中的所有元素
    copy()拷贝一个集合
    difference()返回多个集合的差集
    difference_update()移除集合中的元素，该元素在指定的集合也存在。
    discard()删除集合中指定的元素
    intersection()返回集合的交集
    intersection_update()删除集合中的元素，该元素在指定的集合中不存在。
    isdisjoint()判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
    issubset()判断指定集合是否为该方法参数集合的子集。
    issuperset()判断该方法的参数集合是否为指定集合的子集
    pop()随机移除元素
    remove()移除指定元素
    symmetric_difference()返回两个集合中不重复的元素集合。
    symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
    union()返回两个集合的并集
    update()给集合添加元素

编程

  • 斐波纳契数列

     
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
    print(b)
    a, b = b, a+b
# analysis
# !!! (a,b)=(b,a+b)
# result
# 1
# 1
# 2
# 3
# 5
# 8

  • end关键字

    • 可以将结果输出到同一行

    • 在输出到末尾添加不同的字符

      #!/usr/bin/python3
 
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

# 执行以上程序，输出结果为：
#1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

  • 迭代器

    • 迭代是访问集合元素的一种方式
    • 迭代器对象是从集合的第一个元素开始访问，直到所有的元素被访问完结束
    • 迭代器有2个基本方法
      • iter()
      • next()
    • 字符串、列表或元组对象都可用于创建迭代器

函数

  • 定义

    def 函数名（参数列表）:
    函数体

  • 参数传递

    • 类型属于对象，变量没有类型。

      a=[1,2,3]
a="Test"

    • [1,2,3] 是 List 类型，"Test" 是 String 类型，而变量 a 是没有类型。

      仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

  • 可更改（mutable）与不可更改（immutable）对象

    • **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

    • **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

    • **不可变类型：**类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

    • **可变类型：**类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

    • python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

  • 参数

    • 必须参数
    • 关键字参数
    • 默认参数
    • 不定长参数
      • 参数带一个*
        • 星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
        • 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
      • 参数带2个*
        • 加了两个星号 ** 的参数会以字典的形式导入。
      • 声明函数时，参数中带*可以单独出现
        • 如果单独出现星号*后的参数必须用关键字传入

  • 匿名函数

    • 使用lambda来创建匿名函数
      • lambda的主体是一个表达式，而不是一个代码块，
      • lambda拥有自己的命名空间，且不能访问自己参数列表之外/全局命名空间里的参数

  • return语句

    • return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。
    • 不带参数值的return语句返回None。

  • 变量作用域

    • 程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

    • 变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称

      • L （Local） 局部作用域
      • E （Enclosing） 闭包函数外的函数中
      • G （Global） 全局作用域
      • B （Built-in） 内置作用域（内置函数所在模块的范围）

    • 以 L –> E –> G –>B 的规则查找

      • 在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

    • 作用域

      • 内置作用域

        • 内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。

          import builtins
dir(builtins)

      • Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域。

        • 其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

  • 全局变量和局部变量

    • 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
      • 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
      • 调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

  • global和nonlocal关键字

    • 内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了
    • 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

数据结构

  • 列表
    • Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

py输入和输出

  • Python两种输出值的方式: 表达式语句和 print() 函数。

    • 如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

      print('{1} 和 {0}'.format('Google', 'Test'))
# Test和 Google
print('{name}网址： {site}'.format(name='教程', site='www.test.com'))
# 教程网址： www.test.com

      括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

    • 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

  • 输出格式化

    >>> table = {'Google': 1, 'Test': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))

    其中：{0:10} ==> {1:10d}

    {0}表示索引，指传入对象在format中的位置

    :后面的10/10d表示传入一个整数，可以表示该域至少有这么多的宽度

  • 旧式字符串格式化%

    >>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。
avatar
文章
阅读
粉丝