python笔记day2

发布时间：2019-09-08 09:10:54编辑：auto阅读（1695）

作用域

只要内存中存在就可以使用，在有函数栈的情况下，还需要加一个条件。

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])

关键字：