python笔记

IPython 和 Jupyter Notebooks

启动：终端输入

jupyter notebook 

更改文件存放目录

进入C:\Users\Administrator寻找.jupyter，然后打开py文件寻找，修改设置dir

## The directory to use for notebooks and kernels.
#c.NotebookApp.notebook_dir = 'C:\Users\a\Desktop'

ipython快捷键

ipython指令

ipython运算

标量类型

字符串是一个序列的Unicode字符，因此可以像其它序列，比如列表和元组

In [1]: s = 'python'
In [2]: list(s)
Out[2]: ['p', 'y', 't', 'h', 'o', 'n']

encode 将Unicode字符串编码为UTF-8

一个字节对象的Unicode编码，用 decode 方法可以解码

日期和时间

datetime 模块提供了 datetime 、 date 和 time 类型

strptime 可以将字符串转换成 datetime 对象

strftime 方法可以将datetime格式化为字符串

In [103]: dt = datetime(2011, 10, 29, 20, 30, 21)
In [104]: dt.day
Out[104]: 29

In [106]: dt.date()
Out[106]: datetime.date(2011, 10, 29)

In [107]: dt.time()
Out[107]: datetime.time(20, 30, 21)

In [108]: dt.strftime('%m/%d/%Y %H:%M')
Out[108]: '10/29/2011 20:30'

In [109]: datetime.strptime('20091031', '%Y%m%d')
Out[109]: datetime.datetime(2009, 10, 31, 0, 0)

range

range函数返回一个迭代器，它产生一个均匀分布的整数序列

range的三个参数是（起点，终点，步进）

Python 的数据结构、函数和文件

哈希

python中所有不可改变的的对象（imutable objects）都是可哈希的，比如字符串，元组，也就是说可改变的容器如字典，列表不可哈希（unhashable）

一个对象在其生命周期内，如果保持不变，就是hashable（可哈希的）。

hashable ≈ imutable 可哈希 ≈ 不可变

可以用 hash 函数检测一个对象是否是可哈希的（可被用作字典的键）

In [127]: hash('string')
Out[127]: 5023931463650008331
    In [129]: hash((1, 2, [2, 3]))
    # fails because lists are mutable

元组

tuple 可以将任意序列或迭代器转换成元组

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

元组中存储的对象可能是可变对象。

一旦创建了元组，元组中的对象就不能修改了

元组中的某个对象是可变的，比如列表，可以在原位进行修改

拆分元组

In [18]: tup = 4, 5, (6, 7)
In [19]: a, b, (c, d) = tup
In [20]: d
Out[20]: 7

In [17]: tup[2].append(4)
In [18]: tup
Out[18]: (3, 4, [5, 7, 4])

count （也适用于列表），它可以统计某个值得出现频率

In [34]: a = (1, 2, 2, 2, 3, 4, 2)
In [35]: a.count(2)
Out[35]: 4

列表

append 在列表末尾添加元素

insert 可以在特定的位置插入元素

pop 移除并返回指定位置的元素

remove 去除某个值

in 可以检查列表是否包含某个值

In [25]: b = list(range(1,9,2))

In [26]: b
Out[26]: [1, 3, 5, 7]
    
In [27]: b.append(2)
Out[28]: [1, 3, 5, 7, 2]

In [29]: b.insert(0,4)
Out[30]: [4, 1, 3, 5, 7, 2]
    
In [31]: b.pop()
Out[31]: 2
In [32]: b
Out[32]: [4, 1, 3, 5, 7]
    
In [33]: b.remove(3)
Out[34]: [4, 1, 5, 7]

sort

函数将一个列表原地排序(二级排序key)

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']
In [65]: b.sort(key=len)
In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

sorted

产生一个排好序的序列副本

bisect

支持二分查找，和向已排序的列表插入值

bisect.bisect 可以找到插入值后仍保证排序的位置

sect.insort 是向这个位置插入值

In [50]: a
Out[50]: [2, 4, 3, 1]
In [54]: b = sorted(a,reverse = True)#默认为False
Out[55]: [4, 3, 2, 1]
In [84]: a.sort()
Out[85]: [1, 2, 3, 4]
In [86]: bisect.insort(a,10)#仅仅当顺序时候有用，反顺序可能会出错
Out[87]: [1, 2, 3, 4, 10]

extend

extend方法可以追加多个元素

In [58]: x = [4, None, 'foo']
In [59]: x.extend([7, 8, (2, 3)])

enumerate

enumerate 函数，可以返回 (i, value) 元组序列

In [83]: some_list = ['foo', 'bar', 'baz']
In [84]: mapping = {
   }
In [85]: for i, v in enumerate(some_list):
....: mapping[v] = i
In [86]: mapping
Out[86]: {
   'bar': 1, 'baz': 2, 'foo': 0}

sorted 函数可以从任意序列的元素返回一个新的排好序的列表

zip

zip可以将多个列表、元组或其它序列成对组合成一个元组列表

​ 返回的结果并不是列表，只是一个对象，这个对象可以进行遍历

In [89]: seq1 = ['foo', 'bar', 'baz']
In [90]: seq2 = ['one', 'two', 'three']
In [91]: zipped = zip(seq1, seq2)
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

​ 可以处理任意多的序列，元素的个数取决于最短的序列

In [93]: seq3 = [False, True]
In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]

​ 常见用法之一是同时迭代多个序列，可能结合 enumerate 使用

In [95]: for i, (a, b) in enumerate(zip(seq1, seq2)):
....: print('{0}: {1}, {2}'.format(i, a, b))
....:
0: foo, one
1: bar, two
2: baz, three

In [96]: pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),
....: ('Schilling', 'Curt')]
In [97]: first_names, last_names = zip(*pitchers)
In [98]: first_names
Out[98]: ('Nolan', 'Roger', 'Schilling')
In [99]: last_names
Out[99]: ('Ryan', 'Clemens', 'Curt')

reversed

只有实体化（即列表或for循环）之后才能创建翻转的序列

In [97]: list(reversed(range(10)))
Out[97]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

字典

可以像访问列表或元组中的元素一样，访问、插入或设定字典中的元素

可以用检查列表和元组是否包含某个值的方法，检查字典中是否包含某个键

update 方法可以将一个字典与另一个融合

in[1]:d1 = {
   'a' : 'some value'，'b':'st'}
in[2]:d1.update({
   'b' : 'foo'