python笔记day2
作用域
只要内存中存在就可以使用，在有函数栈的情况下，还需要加一个条件。
name = {'name1':'Carrick','name2','Tina'}
for item in name:
print item -->仅仅是打印，没有将变量指向item内存空间
print item -->无法打印，没有变量指向item的内存空间，print不知道该打印哪个内存空间
name = {'name1':'Carrick','name2','Tina'}
for item in name:
a = item
print a -->可以打印，因为有变量a指向item的内存空间
这个仅仅可以打印name字典的最后一个变量
注意事项：这种for循环中赋值，仅仅可以在python中使用，在其他语言中，for循环的字典会被压入栈中，当for循环执行完毕，栈会被清空，即使a = item，因为item的内存空间被清空，a找不到内存中的位置，print a也不会成功。因此不要在Python的for循环中使用赋值。
三目运算
三目运算是if...else结构的简写
if a > b:
name = 'Carrick'
else
name = 'Tina'
写为三目运算：
name = 'Carrick' if a > b else 'Tina'
PyCharm
PyCharm用专业版，社区版不支持Django
PyCharm使用步骤：
第一步：指定Python解释器
PyCharm本身没有自带解释器，必须指定Python解释器，才能正常运行Python程序
第二步：
New Project --> Pure Python --> New --> Python File
第三步：
打断点，dubug模式运行
run正常模式运行
Python中一切皆对象，对象是由类创建的，对象可以调用相关类的属性和方法
查找类提供哪些方法：
>>> li = [11,22,33]
>>> type(li) -->查看li所属类型
<type 'list'>
>>> dir(list) -->查看类型提供哪些方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
'__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
, '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'a
ppend', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
]
__X__是内置方法，有至少一种执行方法，没有下划线的方法是非内置方法，只有一种执行方式
>>> help(list.append) -->查看具体函数的使用方法
Help on method_descriptor:
append(...)
L.append(object) -- append object to end
PyCharm查看python方法的源码：
敲list，按ctrl点击list，即可看到python的list的源码
int类型常用内置方法
int类型赋值
方法一： i = 10
方法二： i = int(10)
方法三：
>>>i = int("F",base=16) --> 16进制赋值
>>> print i
15
加法
>>> n1 = 1
>>> n2 = 2
>>> n1.__add__(n2) ==>等价于n1 + n2
3
另外：
1. 减法，乘法，除法，幂和取模等运算，只要记住n1-n2，n1*n2，n1/n2，n1**n2和n1%n2，不用记具体的函数
2. int还有radd，add相当于n1+n2，radd相当于n2+n1，int类型还有很多r开头的函数，都是将两个数字掉个
绝对值
>>> n1 = -9
>>> n1.__abs__() ==>等价于abs(n1)
9
大小比较
>>> n1 = 9
>>> n2 = 8
>>> n1.__cmp__(n2) ==>等价于cmp(n1,n2)
1
返回值为1，说明n1大于n2，返回值为0，说明n1等于n2，返回值为-1，说明n1小于n2
生成商和余数的元组 -->用于网站分页显示
>>> n1 = 10
>>> n2 = 3
>>> n1.__divmod__(n2) ==>等价于divmod(n1,n2)
(3, 1)
除法
>>> n1 = 10
>>> n1.__div__(3)
3
int类型转换为float类型
>>> n1 = 10
>>> type(n1)
<type 'int'>
>>> new_n1 = n1.__float__() ==>等价于float(n1)
>>> type(new_n1)
<type 'float'>
获得属性
只有类中写有__getatrribute__属性，敲“.”才能显示出类中可用的属性
获得哈希
x.__hash__() ==>等价于hash(x)
爬虫中URL很长，一般将URL做hash或者md5，形成一个较短的字符串，便于存放在数据库中。
在字典中，如果key很长，哈希值用于快速比较key的值
获得n进制数字
>>> n = 18
>>> n.__hex__() ==>等价于hex(n),获得十六进制数字
'0x12'
>>> n.__oct__() ==>等价于oct(n),获得八进制数字
'022'
整数部分截取 -->对整数无意义
>>> n = 5.2
>>> n.__trunc__()
5
long型和float型的方法和int型方法几乎一样
str类型
str定义
str1 = "Carrick" 或者
str1 = str("Carrick")
字符串首字母大写
>>> name = 'Carrick'
>>> name.capitalize()
'Carrick'
字符串居中
>>> name = 'Carrick'
>>> name.center(20,"*")
'******Carrick*******'
查找子串的个数
>>> name = "djkajs;kfljdaksjkds"
>>> name.count("s")
3
>>> name.count("s",8,20) -->指定起始位置和结束位置
2
字符串结尾判断
>>> name = 'Carrick'
>>> name.endswith('ck')
True
>>> name.endswith('ck',2,) -->第二个字符到最后一个字符，以ck结尾
True
**将tab转换为空格
默认情况下一个tab转换为8个空格
将tab转换为空格，然后用strip()函数将所有空格去掉，就可以取到配置文件中的参数
>>> name = 'Carri ck' -->中间有tab键
>>> name.expandtabs()
'Carri ck'
>>> name.expandtabs(1) -->转换成一个空格
'Carri ck'
查找子串的位置：find和index
>>> name = 'Carrick'
>>> name.find('ri')
3
>>> name.find('Fairy')
-1
>>> name = 'Carrick'
>>> name.index('ri')
3
>>> name.index('Fairy')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>
find找到返回子串第一个字符的位置，找不到返回-1；如果有相同的子串，会返回第一个子串的位置
index找到返回子串第一个字符的位置，找不到报错
判断字符串是否为数字或者字母
>>> name = 'Carrick'
>>> name.isalnum()
True
>>> name = '老毕'
>>> name.isalnum()
False
是数字或者字符返回True，是其它值返回False
判断字符串是否为字母
>>> name = 'Carrick'
>>> name.isalpha()
True
>>> name = 123
>>> name.isalpha()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isalpha'
>>>
是字母返回True，是其它值报错
判断字符串是否为数字
>>> name = 123
>>> name.isdigit()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit'
>>> name = '123'
>>> name.isdigit()
True
是数字返回True，是其它值报错
判断字符串是否全是小写
>>> name = 'carrick'
>>> name.islower()
True
>>> name = 'Carrick'
>>> name.islower()
False
isupper() 判断字符串是否全为大写
isspace() 判断字符串是否全为空格
转换为标题
>>> name = 'hello carrick'
>>> name.istitle()
False
>>> name.title()
'Hello Carrick'
>>> name = 'Hello Carrick'
>>> name.istitle()
True
istitle() 判断字符串是否标题
>>> name = 'hello carrick'
>>> name.istitle()
False
>>> name = 'Hello Carrick'
>>> name.istitle()
True
标题就是每个单词首字母大写
**字符串连接
>>> L = ['s1','s2']
>>> "_".join(L)
's1_s2'
左对齐ljust()
>>> name = 'Carrick'
>>> name.ljust(20,"+")
'Carrick+++++++++++++'
右对齐：rjust()
大写变小写lower()；小写变大写upper()
>>> name = 'Carrick'
>>> name.lower()
'carrick'
>>> name.upper()
'CARRICK'
大写变小写，小写变大写swapcase()
>>> name = 'Carrick'
>>> name.swapcase()
'cARRICK'
字符串分割paritition()
>>> name = 'Carrick'
>>> name.partition('rr')
('Ca', 'rr', 'ick')
**字符替换replace()
>>> name = 'Carrick'
>>> name.replace('Ca','ca')
'carrick'
>>> name = 'Carrick'
>>> name.replace('r','hhhh')
'Cahhhhhhhhick'
replace()会替换所有的字符，不仅仅替换第一个字符
字符转相乘（python特有的）
>>> name = 'Carrick'
>>> name*6
'CarrickCarrickCarrickCarrickCarrickCarrick'
字符串格式化
方法一：
>>> name = "I am {0}, I am {1} years old."
>>> name.format('Carrick','34')
'I am Carrick, I am 34 years old.'
方法二：
>>> name = "I am {ss}, I am {dd} years old."
>>> name.format(dd="34", ss="Carrick")
'I am Carrick, I am 34 years old.'
方法三：元组，列表传参，需要加“*”
>>> L = ['Carrick',34]
>>> name = "I am {0},aged {1}"
>>> name.format(*L)
'I am Carrick,aged 34'
方法四：字典传参，需要加“**”
>>> D = {'ss':'Carrick','dd':34}
>>> name = "I am {ss},aged {dd}"
>>> name.format(**D)
'I am Carrick,aged 34'
解码和编码
utf-8和GBK可以通过unicode来相互转换，不可以直接转换
>>> '无'
'\xce\xde'
>>> str1 = '\xce\xde'
>>> print str1
无
>>> print str1.decode('gbk') -->指定从哪个编码解码
无
>>> print str1.decode('gbk').encode('utf-8')
鏃
列表的方法（二）
列表元素出现的次数
>>> L = [66,77,88]
>>> L.count(88)
1
>>> L.count(22)
0
列表扩展
>>> L = [66,77,88]
>>> L.extend(['Carrick','Tina'])
>>> L
[66, 77, 88, 'Carrick', 'Tina']
>>> L.extend(L)
>>> L
[66, 77, 88, 'Carrick', 'Tina', 66, 77, 88, 'Carrick', 'Tina']
列表可以自己扩展自己
列表元素查找
>>> L = [66,77,88]
>>> L.index(66)
0
>>> L.index(22)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 22 is not in list
列表指定位置插入
>>> L = [66,77,88]
>>> L.insert(0,88)
>>> L
[88, 66, 77, 88]
删除并返回指定下标的值，不指定下标就弹出最后一个元素
>>> L
[88, 66, 77, 88]
>>> L.pop()
88
>>> L
[88, 66, 77]
>>> L.pop(1)
66
>>> L
[88, 77]
删除列表第一个值
>>> L = [66,77,88,66]
>>> L.remove(66)
>>> L
[77, 88, 66]
列表翻转
>>> L = [66,77,88]
>>> L.reverse()
>>> L
[88, 77, 66]
列表元素排序
字母比较ASCII，中文比较Unicode，数字比较大小
>>> '无'
'\xce\xde'
>>> str1 = '\xce\xde'
>>> str1.decode('gbk')
u'\u65e0'
>>> str2 = u'\u65e2'
>>> print str2
既
>>> li = ['无','既']
>>> li.sort()
>>> li
['\xbc\xc8', '\xce\xde']
unicode的编码，'\xce\xde'是u'\u65e0'，'\xbc\xc8'是u'\u65e2'，因此sort()将大的排在前面
>>> for i in li:
... print i
...
既
无
列表元素删除
del name[1]是调用__delitem__()方法来执行的
元组和列表的唯一区别，就是列表可以被修改，而元组不能被修改
列表和元组的元素都可以是重复的
元组的元素不能被修改，但是元组的元素的元素可以被修改
字典的key不能重复，value可以重复
元组方法：index(),count()
字典
修改字典，不会在内存中重新开辟一块空间，只有字符串会
字符串，数字可以作为字典的key，列表不能作为字典的key，元组可以作为字典的key，但是不要这么做
字符串，数字和类的实例当做字典的key没有问题
字典根据key获得value
方法一：字典中没有值会报错
>>> d = {'k1':1234}
>>> d['k1']
1234
>>> d['k2']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'k2'
***方法二：字典中没有值不会报错
>>> d = {'k1':1234}
>>> d.get('k1')
1234
>>> d.get('k2')
>>> print d.get('k2') -->默认返回值
None
>>> print d.get('k2','OK') -->指定返回值
OK
判断是否为字典
>>> d = {'k1':1234}
>>> type(d) is dict
True
清空字典
>>> D = {1:'a'}
>>> D.clear()
>>> D
{}
第一个列表作为字典的key，生成字典
>>> D = {}
>>> D.fromkeys([1,2,3],[4,5,6])
{1: [4, 5, 6], 2: [4, 5, 6], 3: [4, 5, 6]}
有时有个列表，想以列表为key生成字典，就可以
>>> D.fromkeys([1,2,3],[])
{1: [], 2: [], 3: []}
生成一个value为空的字典，然后往里面插入value即可
判断key是否在字典中
方法一
>>> D = {1:'a'}
>>> D.has_key(1)
True
方法二
>>> 1 in D
True
循环字典
方法一：数据量小的时候可以用，几万条数据之内可以用
>>> D = {1:'a',2:'b',3:'c'}
>>> for k,v in D.items():
... print k,v
...
1 a
2 b
3 c
方法二：数据量大时用
>>> for k in D:
... print k,D[k]
...
1 a
2 b
3 c
根据key删除字典元素
方法一：
>>> D = {1:'a',2:'b',3:'c'}
>>> D.pop(2)
'b'
>>> D
{1: 'a', 3: 'c'}
方法二：
>>> D
{1: 'a', 3: 'c'}
>>> del D[3]
>>> D
{1: 'a'}
随机删除字典元素：popitems()，不要使用
根据key查找元素,如果没有就生成一个None
>>> D = {1:'a',2:'b',3:'c'}
>>> D.setdefault(2)
'b'
>>> D
{1: 'a', 2: 'b', 3: 'c'}
>>> D.setdefault(4)
>>> D
{1: 'a', 2: 'b', 3: 'c', 4: None}
将另一个字典的元素加入到当前字典，如果有相同的key，取另一个字典的key和value（偶尔用）
>>> C = {1:'a',2:'b',3:'c'}
>>> D = {4:'d',5:'e',3:'f'}
>>> C.update(D)
>>> C
{1: 'a', 2: 'b', 3: 'f', 4: 'd', 5: 'e'}
字典浅copy
>>> D = {}
>>> for i in range(5):
... D[i] = []
...
>>> D
{0: [], 1: [], 2: [], 3: [], 4: []}
>>> D[1].append({"b":1})
>>> D
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}
>>> C = D
>>> C
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}
>>> D
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}
>>> D['Rain'] = 'test'
>>> D
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'Rain': 'test'}
>>> C
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'Rain': 'test'}
D修改了，C也跟这个修改；如果是字符串，D修改了，C不会随着修改
>>> E = D.copy()
>>> D.pop('Rain')
'test'
>>> D
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}
>>> E
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'Rain': 'test'}
>>> C
{0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}
如果使用copy()，E会是另外一个字典，D删除一个元素，E不会随着删除
>>> D[1][0]['b'] = 'Carrick'
>>> D
{0: [], 1: [{'b': 'Carrick'}], 2: [], 3: [], 4: []}
>>> C
{0: [], 1: [{'b': 'Carrick'}], 2: [], 3: [], 4: []}
>>> E
{0: [], 1: [{'b': 'Carrick'}], 2: [], 3: [], 4: [], 'Rain': 'test'}
注意：浅copy只复制字典的第一层
深copy：需要借助第三方模块
>>> import copy
>>> F = copy.deepcopy(D)
>>> F
{0: [], 1: [{'b': 'Carrick'}], 2: [], 3: [], 4: []}
>>> D[1][0]['b'] = 'Fairy'
>>> D
{0: [], 1: [{'b': 'Fairy'}], 2: [], 3: [], 4: []}
>>> E
{0: [], 1: [{'b': 'Fairy'}], 2: [], 3: [], 4: [], 'Rain': 'test'}
>>> C
{0: [], 1: [{'b': 'Fairy'}], 2: [], 3: [], 4: []}
>>> F
{0: [], 1: [{'b': 'Carrick'}], 2: [], 3: [], 4: []}
集合：去重，交集，差集，并集等的运算
集合/字典是无序的，列表/元组是有序的
列表/字典/集合可以修改，元组不能修改
>>> a = range(5,10)
>>> b = range(7,12)
>>> a
[5, 6, 7, 8, 9]
>>> b
[7, 8, 9, 10, 11]
>>> c = set(a)
>>> c
set([8, 9, 5, 6, 7])
>>> a.append(6)
>>> a
[5, 6, 7, 8, 9, 6]
>>> c
set([8, 9, 5, 6, 7])
>>> d = set(b)
>>> d
set([8, 9, 10, 11, 7])
>>> c
set([8, 9, 5, 6, 7])
>>> c & d -->交集
set([8, 9, 7])
>>> c | d -->并集
set([5, 6, 7, 8, 9, 10, 11])
>>> c ^ d -->交集取反
set([5, 6, 10, 11])
>>> c - d -->c有d没有的元素
set([5, 6])
>>> d - c -->d有c没有的元素
set([10, 11])
intersection --> &
uNIOn --> |
symmetric_difference --> ^
子集和父集
>>> e = set([8,10])
>>> e
set([8, 10])
>>> d
set([8, 9, 10, 11, 7])
>>> e.issubset(d)
True
>>> d.issuperset(e)
True
弹出集合第一个元素
>>> c
set([8, 9, 5, 6, 7])
>>> c.pop()
8
>>> c.pop()
9
删除集合指定元素
set([5, 6, 7])
>>> c.remove(6)
>>> c
set([5, 7])
加入另外一个集合的元素
>>> c = set([5, 7, 8, 10])
>>> f = set([10,11])
>>> c.update(f)
>>> c
set([5, 7, 8, 10, 11])
集合不能有重复元素
集合使用场景：资产管理统计硬盘数量
硬盘使用S/N号来识别，这里用1,2简单说明一下
diskset = set([1,2])
坏掉一块硬盘后
diskset1 = set([1])
可以发现硬盘2是坏掉的，写入到数据库中
>>> diskset - diskset1
set([2])
增加了硬盘后：
diskset2 = set([1,3,4,5])
可以发现硬盘3,4,5是新增加的硬盘，写入到数据库中
>>> diskset2 - diskset1
set([3, 4, 5])
相关文章