首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >python笔记day2

python笔记day2

作者头像
py3study
发布2020-01-08 16:08:08
8140
发布2020-01-08 16:08:08
举报
文章被收录于专栏:python3python3

作用域

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

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'

 解码和编码

wKiom1lk3IGQbZxRAAFoDhPhj9E966.png-wh_50
wKiom1lk3IGQbZxRAAFoDhPhj9E966.png-wh_50

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

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2019-09-08 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档