专栏首页python3python笔记day2

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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 浏览器中Get与POST请求的区别

    本文采用CC BY-NC-SA 3.0 Unported协议进行许可,转载请保留此文章链接

    Debug客栈
  • 使用Redis实现高流量的限速器

    Redis是生产环境中默默无闻的主力配置。它不常用作主要的数据存储,但它可存储和访问临时数据(度量,会话状态,缓存等损失可以容忍的数据)方面有一个...

    物流IT圈
  • OpenCV系列之直方图-2:直方图均衡 | 二十七

    考虑这样一个图像,它的像素值仅局限于某个特定的值范围。例如,较亮的图像将把所有像素限制在高值上。但是一幅好的图像会有来自图像所有区域的像素。因此,您需要将这个直...

    磐创AI
  • Smarty踩坑日记 变量调解器

    {$yesterday|date_format:”:”%A, %B %e, %Y %H:%M:%S”}

    Debug客栈
  • 数据库复习题 考试题库(填空题)

    1.数据库系统一般由(数据库)、应用系统、(数据库管理系统)、(数据库管理员)和用户构成。

    Debug客栈
  • 传感器是未来世界的核心(上)

    我们知道未来整个科技行业最大的主题是5G,5G是整个通信的基础设施,在5G之后主要是三个问题,第一个是如何输入数据,第二是如何处理数据,第三,如何输出转化数据。...

    物流IT圈
  • 用人工智能生成的数据,来培训其他人工智能模型

    生成式对抗网络(GANs)由生成样本的生成器和试图区分生成样本和真实样本的鉴别器组成,这两部分AI系统有无数的用途,其中之一就是生成合成数据。优步(Uber)的...

    AiTechYun
  • 自然语言处理的黄金时代

    自然语言处理(NLP)已有数十年的历史,但是它缺乏一般的现实世界智能。机器可能擅长数学,但是很难将涉及语音和文本的语言问题转换为他最擅长的数学公式。然而,根据N...

    AiTechYun
  • 蓝桥杯 基础练习 阶乘计算

    n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。...

    Debug客栈
  • 蓝桥杯 基础练习 完美的代价

    回文串,是一种特殊的字符串,它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串,它不一定是回文的,请你计算最少的交换次数使得该串变成一...

    Debug客栈

扫码关注云+社区

领取腾讯云代金券