来自 威尼斯国际官方网站 2019-11-28 04:53 的文章
当前位置: 威尼斯国际官方网站 > 威尼斯国际官方网站 > 正文

python学习笔记3

再次重申学习的是某位THU大神,网址贴下

## Python 中有四种用于存放数据的序列--list, tuple, dict, set

## list 列表
  - 可以存放任意类型数据的有序序列
  - 列表可以由零个或多个元素组成,元素之间用逗号分开,整个列表被方括号所包裹:
  - 创建
    - 使用[]或者list()创建列表
    - new_list = ["Stanley", "Loves", "Lily"]

只贴了我不太熟悉的 适合有其他编程语言基础的看

  - 访问及修改
    - 使用列表名[索引]来访问和修改列表元素,索引初始值为0,最大值不超过列表长度

Chat 4 list

列表的加法,相当于将两个列表按顺序连接

a = [1, 2, 3]
b = [3.2, 'hello']
a + b
l = [1, 2.0, 'hello']
l * 2
# 列表与整数相乘,相当于将列表重复相加

我们知道字符串是无法直接进行修改的,那么要修改其中的一个类型怎么办呢?

如果转化list的话,那就简单许多了

>>> s='abcdef'                  #原字符串
>>> s1=list(s)                  #将字符串转换为列表
>>> s1                         
['a', 'b', 'c', 'd', 'e', 'f']  #列表的每一个元素为一个字符
>>> s1[4]='E'                   #将列表中的第5个字符修改为E
>>> s1[5]='F'                   #将列表中的第5个字符修改为E
>>> s1
['a', 'b', 'c', 'd', 'E', 'F']  
>>> s=''.join(s1)               #用空串将列表中的所有字符重新连接为字符串
>>> s
'abcdEF'                        #新字符串

list当中的整段替换

a = [10, 11, 12, 13, 14]
a[1:3] = [1, 2, 3, 4]
print a

对于不连续(间隔step不为1)的片段进行修改时,两者的元素数目必须一致:

否则会报错

a = [10, 11, 12, 13, 14]
a[::2] = [1, 2, 3]
a[::2] = []
# 上面这一句 右边为空,所以无法运行

删除元素

a = [1002, 'a', 'b', 'c']
del a[0]
del a[1:]
del a[::2]

测试从属关系

a = [10, 11, 12, 13, 14]
print 10 in a
print 10 not in a
# 同样可以用于字符串
s = 'hello world'
print 'he' in s
print 'world' not in s

list.count(object) 返回元素的次数

list.index(object) 返回元素第一次

list.append(object) 将元素object添加了列表最后

list.extend(newList) 将newList添加到列表最后,这里和 list += newList 一样

l.insert(idx, ob)在索引 idx处插入 ob ,之后的元素依次后移

l.remove(ob)移除元素

l.pop(idx) 将索引处的元素删除

a = [10, 11, 12, 13, 11]
# 在索引 3 插入 'a'
a.insert(3, 'a')
print a 
a = [10, 11, 12, 13, 11]
# 移除了第一个 11
a.remove(11)
print a
a = [10, 11, 12, 13, 11]
a.pop(2)

sorted可以不影响原来的元素

a = [10, 1, 11, 13, 11, 2]
b = sorted(a)
print a
print b

除了a.reverse()的取反方法,还有如下的方式

a = [1, 2, 3, 4, 5, 6]
b = a[::-1]

介绍一个深拷贝和浅拷贝的问题,知道C++应该对这个概念很熟悉

下面这个例子应该非常明显的

b = [12, 23]
a = b
b[1] = 99
a
# 下面这个例子是所谓的深拷贝
b = [12, 23]
import copy
a = copy.copy(b)
b[1] = 99
a
# 还有一种deepCopy,是比copy更深的拷贝,对于list内部的list也是深拷贝
  • 1
        - print(new_list[1]) # -> "Loves"
        - new_list[1] = "Adores"
        - print(new_list) # -> ['Stanley', 'Adores', 'Lily']
        - 若索引可以为负数,则是从列表末尾以-1为初始值开始计数

Chat 5 tuple and dictionary

与列表相似,元组Tuple也是个有序序列,但是元组是不可变的,用()生成。

t = (10, 11, 12, 13, 14)

一个元素的元组

a = (10,)
type(a)
# 下面这种写法其实不是元组
a = (10)
type(a)

除此之外,还有a.count(obt) a.index(obj)这种和list差不多的功能

下面稍微比较下tuple和list

测试之前我主观认为tuple的速度是比list快

%timeit可以测试一个时间

%timeit [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
%timeit (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25)

from numpy.random import rand
values = rand(10000,4)
lst = [list(row) for row in values]
tup = tuple(tuple(row) for row in values)
%timeit for row in lst: list(row)
%timeit for row in tup: tuple(row)

最后的结论是元组的生成速度会比列表快很多

下面的时候介绍下dictionary

出于hash的目的,Python中要求这些键值对的必须是不可变的,而值可以是任意的Python对象。

synonyms = {}
synonyms['mutable'] = ['changeable', 'variable', 'varying', 'fluctuating',
                       'shifting', 'inconsistent', 'unpredictable', 'inconstant',
                       'fickle', 'uneven', 'unstable', 'protean']
synonyms['immutable'] = ['fixed', 'set', 'rigid', 'inflexible', 
                         'permanent', 'established', 'carved in stone']
synonyms

dict还可以嵌套dict,如下的例子

# 定义四个字典
e1 = {'mag': 0.05, 'width': 20}
e2 = {'mag': 0.04, 'width': 25}
e3 = {'mag': 0.05, 'width': 80}
e4 = {'mag': 0.03, 'width': 30}
# 以字典作为值传入新的字典
events = {500: e1, 760: e2, 3001: e3, 4180: e4}
events

除了通常的定义方法,还可以通过dict()转化来生成字典

inventory = dict(
    [('foozelator', 123),
     ('frombicator', 18), 
     ('spatzleblock', 34), 
     ('snitzelhogen', 23)
    ])
inventory['frombicator'] += 1
# 直接更新每种键值
inventory

person = {}
person['first'] = "Jmes"
person['last'] = "Maxwell"
person['born'] = 1831
print person
person_modifications = {'first': 'James', 'middle': 'Clerk'}
person.update(person_modifications)
# 除了正常的person的表示,还可以使用

不知道某种key是否存在?可以尝试使用

a = {}
a["one"] = "this is number 1"
a["two"] = "this is number 2"
a.get("one")
a.get("three", "undefined")
# 如果没有这个key,就输出undefined

Dictionary可以使用pop删除元素,这里和list类似

细心的童鞋应该记得

list的删除是a.pop(2),删除第几个元素

dict的删除是a.pop("two"), 删除相应的键值

a.pop("two", 'not exist')
# 如果不存在就输出not exist
del a["one"]
# del和pop同样的功能

d.keys()返回一个由所有键组成的列表;

d.values()返回一个由所有值组成的列表;

d.items()返回一个由所有键值对元组组成的列表;

  - 使用[start, end, step]分片生成新的列表(新列表和旧列表位于不同内存地址)
    - [:]提取从开头到结尾的整个字符串
    - [start:]从start提取到结尾
    - [:end]从开头提取到 end - 1
    - [start:end]从start提取到end - 1
    - [start:end:step]从start提取到end - 1,每隔step个字符提取
    - start,end,step可以为负数,start和end为负数表示从右往左数,从-1开始计数,step为负数则表示倒序

  - 与列表有关的常用函数
    - len(a_list):返回列表长度
    - a_list.append(新元素):将新元素添加至列表末尾
    - a_list.extend(another_list):将another_list添加至a_list末尾,可以使用 += 达到相同效果, a_list += another_list
    - a_list.insert(index, 新元素):将新元素插入列表指定位置,若index的值大于列表长度,则将新元素插入列表末尾
    - del a_list[index]:删除指定位置的元素,index的值必须小于列表长度
    - del不是函数,而是Python语句,是赋值语句(=)的逆过程,它将变量和值之间的绑定解除
    - a_list.remove(元素):删除指定值的元素
      a_list = ['a', 'b', 'c']
      a_list.remove('b')
      print(a_list) # -> ['a', 'c']
    - a_list.pop(index):弹出指定位置的元素,index默认为-1
    - a_list.index(元素):如果列表中存在指定元素,则返回该元素的索引
    - 使用 in 判断某列表中是否存在某值,若存在,返回True,若不存在,返回False
    - a_list.count(元素):返回元素中某元素出现的次数
    - a_list.sort():列表排序,默认为升序,通过添加参数 reverse=True 可以改变为降序排列
    - a_list.copy():返回一个不同内存地址但列表值相同的新列表,浅拷贝,只能拷贝一层内容,对于嵌套列表的内存地址不做改变

  - 列表修改问题
    - 示例:
      a = [1, 2, 3] # -> 创建新列表
      b = a # -> 让b和a指向同一内存地址
      b[1] = "a" # -> 通过b修改列表中第二个元素
      print(a) # 输出[1, 'a', 3],由于指向同一内存,因此对b的修改同样会影响到a

  - 可以通过copy()函数、list()转换函数和[:]分片生成新的不同内存地址的列表,如此对新列表的修改就不会影响到旧列表的内容

## tuple 元组
  - 使用()或者tuple()创建元组
  - 元组可以看作不可更改的列表
  - 相对而言,元组比列表占用的空间少
  - 元组特性和列表基本相同,但不能使用更改元素内容的相关函数,例如append()、insert()等
  - 创建注意事项
    - 若元组内只有一个元素,在元素后需要有一个逗号表示这是一个元组
    - 也可以不用括号创建,但需要在元素后需要有一个逗号表示这是一个元组
      a = 1,
      print(type(a)) # -> <class 'tuple'>

 

## dict 字典
  - 一种组合数据,没有顺序,数据以键值对的形式出现
  - 创建: d = {} 或者 d = dict()
    d = {
      key1: value1,
      key2: value2,
      ...
      key_n: value_n
    }

  - 特性
    - 字典是序列类型,但是是无序序列,所以没有索引和切片
    - 字典中的所有数据都是键值对
    - key必须是可哈希的数值,比如int str, float, tuple等,但是list, set, dict等不行
    - value可以是任何值
    - 删除: del dic[key] # -> 删除整个键值对

本文由威尼斯国际官方网站发布于威尼斯国际官方网站,转载请注明出处:python学习笔记3

关键词: