3.20-3.23

3.20

list

1.添加新元素

• append()，直接添加到列表的末尾

例如：

L= [ 'apple', 'pear' ]
L.append('grape')
print L 
[ 'apple', 'pear' , 'grape'] 复制代码

•  insert()，插入至相应的位置

例如：

L = [ 'apple', 'pear' ]
L.insert(1,'grape')     
print L 
[ 'apple', 'grape', 'pear'] 复制代码

2.删除元素

• pop()，删除元素

例如：

L= [ 'apple', 'pear' ]
L.pop(0)
print L 
[ 'apple'] 
复制代码

3.替换元素

L= [ 'apple', 'pear' ]
L[0] = 'grape'
print L
[ 'grape', 'pear' ]复制代码

4. 清空元素

list.clear()

5. 在list 后面添加一个新列表

list.extend(list)

6. 用下标和数值遍历列表

• for idx,value in enumerate(list):print(idx,value) 
  
• for idx in range(len(list)):print(idx,list[idx])
  

7. 自身翻转

list.reverse()

2. tuple

1.  与list不一样，tuple的元素是不可变的，其中list用[]，tuple用()

t = ('Adam', 'Lisa', 'Bart')复制代码

tuple的不可删除元素，也不可添加、替换元素

索引方式与list相同

2.创建tuple

t = ()
print t
()复制代码

↑ 这是一个空tuple

** 有一个特殊情况——创建含有一个元素的tuple

t = (1)
print t
1复制代码

 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1

因此，会以tuple(1,)的方式与tuple(1)区分。

t = (1,)
print t
(1,)复制代码

t = (1, 2, 3)
print t
(1, 2, 3)
复制代码

3.21 ——今天安装了python社区版以及anaconda

(2)存在一个tuple“可变”的情况

t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'C'
L[1] = 'D'
print t
('a', 'b', ['C', 'D'])复制代码

虽然看似tuple变了 ，但其实改变的还是list（即['A', 'B']),若要tuple完全不可变，可将代码改为

t = ('a', 'b', ('A', 'B'))复制代码

3. for语句

1.

L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name复制代码

name是在for循环中定义的

for name in L:

多重循环  ↓

for x in ['A', 'B', 'C']:
    for y in ['1', '2', '3']:
        print x + y复制代码

意为将依次取出list中的每一个元素，并把元素赋值给 name

2.

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    print x[0] + ':', x[1]复制代码

用for循环语句遍历set的元素，将set中的每个元素看做一个tuple，存入x，例如x[0]即为‘Adam’95

4. break，continue

break 是退出循环，执行循环体外的下一语句

continue 是执行完continue 后继续下一次循环

5.dict（查找表）

1.

['Adam', 'Lisa', 'Bart']
复制代码

[95, 85, 59]复制代码

'Adam' ==> 95
'Lisa' ==> 85
'Bart' ==> 59复制代码

构成查找表  ==>

dict就是通过key来查找value（其中key是对应上面的人名，value对应成绩）

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}复制代码

key：value  （逗号可以省略）

len() 函数可以计算任意集合的大小

len(d)

print d['Adam']
95复制代码

输入key 输出value

也可以用以下代码判断某一key是否存在在dict中

if 'Paul' in d:
    print d['Paul']复制代码

也可以用这种办法

print d.get('Bart')
59
print d.get('Paul')
None复制代码

如果key中没有，则返回None，若有，则输出value

2. 更新dict

d['key']=value

3.22

1. python读写文件的方法

• 读取文件的对象 ： fin = open("data.txt")
  
• 写出文件的对象 ： fout = open("data.txt","w")
  

            有两个参数 其中data为文件名，txt为可选格式，如果想写出文件，则加一个“w”的字符串

• 读取文件的全部内容 ： whole_data = fin.read()
  
• 按行读取文件的内容 ： for line in fin : print(line)
• 写出一行数据到文件 ：fout.write("xyz\n")     

           我们要自己加上\n，让字符串换行，如果没有那么字符串会在一行

• 文件的关闭： fin.close()和fout.close()
  
• 写大文件时刷新文件：fout.flush()

2.  strip()可以将字符串的 换行符去掉

3.  我在pycharm中运行了

4. 字符串的切片 

• list[begin:end] 包括begin不包括end
  
• 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。 ↓

>>> L[::2]
['Adam', 'Bart']复制代码

5. 

• dict无序，查找速度快，占用内存，元素不可变
  
• list有序，查找速度慢 ，不占用内存，元素可变
  

3.23

1. set

s = [1,2,3]

• 添加元素  s.add()
  
• 移除元素  s.remove()

       只能移除set中已有的元素，如果移除的是不存在的元素则会报错

2.函数

• #math 包含了很多数学函数，用import引用 即 import math
• Python的函数返回多值其实就是返回一个tuple
  
• 使用递归函数需要注意防止栈溢出。因为每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
  
• Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数
  
• int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
• 由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
  

3.range()函数可以创建一个数列：

>>> range(1, 101)
[1, 2, 3, ..., 100]复制代码

注意不是到101，而是到100

4.字符串切片

• 字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串
  

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'复制代码

5. 字符串有个方法 upper() 可以把字符变成大写字母

6. 迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

• 有序集合：list，tuple，str和unicode；
  
• 无序集合：set 
  
• 无序集合并且具有 key-value 对：dict
  

7.  迭代永远是取出元素本身，而非元素的索引

如果想在 for 循环中拿到索引，方法是使用 enumerate() 函数

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul复制代码

其中 index即为每个元素的索引

实际上，enumerate() 函数把：

['Adam', 'Lisa', 'Bart', 'Paul']复制代码

变成了类似：

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]复制代码

因此，迭代的每一个元素实际上是一个tuple

• 索引迭代——由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

8.zip()函数可以把两个 list 变成一个 list

9.迭代dict的value

values() 方法（或者itervalues()）这个方法把dict转换成一个包含所有value的list

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]复制代码

• values() 方法实际上把一个 dict 转换成了包含 value 的list，但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
  

10.  迭代dict的key和value

items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]复制代码

• 和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
  

11.  如果要生成[1x1, 2x2, 3x3, ..., 10x10]

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
... 
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]复制代码

或者

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]复制代码

12.  for 循环后面还可以加上 if 判断

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]复制代码

13.  for循环可以嵌套

对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']复制代码

其实等价于下面的代码：

L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)复制代码

转载于:https://juejin.im/post/5c92461ee51d454a284a4aef