python开发学习-day02(元组、字符串、列表、字典深入)

s12-20160109-day02

*:first-child {
margin-top: 0 !important;
}

body>*:last-child {
margin-bottom: 0 !important;
}

/* BLOCKS
=============================================================================*/

p, blockquote, ul, ol, dl, table, pre {
margin: 15px 0;
}

/* HEADERS
=============================================================================*/

h1, h2, h3, h4, h5, h6 {
margin: 20px 0 10px;
padding: 0;
font-weight: bold;
-webkit-font-smoothing: antialiased;
}

h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code {
font-size: inherit;
}

h1 {
font-size: 28px;
color: #000;
}

h2 {
font-size: 24px;
border-bottom: 1px solid #ccc;
color: #000;
}

h3 {
font-size: 18px;
}

h4 {
font-size: 16px;
}

h5 {
font-size: 14px;
}

h6 {
color: #777;
font-size: 14px;
}

body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child {
margin-top: 0;
padding-top: 0;
}

a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
margin-top: 0;
padding-top: 0;
}

h1+p, h2+p, h3+p, h4+p, h5+p, h6+p {
margin-top: 10px;
}

/* LINKS
=============================================================================*/

a {
color: #4183C4;
text-decoration: none;
}

a:hover {
text-decoration: underline;
}

/* LISTS
=============================================================================*/

ul, ol {
padding-left: 30px;
}

ul li > :first-child,
ol li > :first-child,
ul li ul:first-of-type,
ol li ol:first-of-type,
ul li ol:first-of-type,
ol li ul:first-of-type {
margin-top: 0px;
}

ul ul, ul ol, ol ol, ol ul {
margin-bottom: 0;
}

dl {
padding: 0;
}

dl dt {
font-size: 14px;
font-weight: bold;
font-style: italic;
padding: 0;
margin: 15px 0 5px;
}

dl dt:first-child {
padding: 0;
}

dl dt>:first-child {
margin-top: 0px;
}

dl dt>:last-child {
margin-bottom: 0px;
}

dl dd {
margin: 0 0 15px;
padding: 0 15px;
}

dl dd>:first-child {
margin-top: 0px;
}

dl dd>:last-child {
margin-bottom: 0px;
}

/* CODE
=============================================================================*/

pre, code, tt {
font-size: 12px;
font-family: Consolas, "Liberation Mono", Courier, monospace;
}

code, tt {
margin: 0 0px;
padding: 0px 0px;
white-space: nowrap;
border: 1px solid #eaeaea;
background-color: #f8f8f8;
border-radius: 3px;
}

pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}

pre {
background-color: #f8f8f8;
border: 1px solid #ccc;
font-size: 13px;
line-height: 19px;
overflow: auto;
padding: 6px 10px;
border-radius: 3px;
}

pre code, pre tt {
background-color: transparent;
border: none;
}

kbd {
-moz-border-bottom-colors: none;
-moz-border-left-colors: none;
-moz-border-right-colors: none;
-moz-border-top-colors: none;
background-color: #DDDDDD;
background-image: linear-gradient(#F1F1F1, #DDDDDD);
background-repeat: repeat-x;
border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD;
border-image: none;
border-radius: 2px 2px 2px 2px;
border-style: solid;
border-width: 1px;
font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
line-height: 10px;
padding: 1px 4px;
}

/* QUOTES
=============================================================================*/

blockquote {
border-left: 4px solid #DDD;
padding: 0 15px;
color: #777;
}

blockquote>:first-child {
margin-top: 0px;
}

blockquote>:last-child {
margin-bottom: 0px;
}

/* HORIZONTAL RULES
=============================================================================*/

hr {
clear: both;
margin: 15px 0;
height: 0px;
overflow: hidden;
border: none;
background: transparent;
border-bottom: 4px solid #ddd;
padding: 0;
}

/* TABLES
=============================================================================*/

table th {
font-weight: bold;
}

table th, table td {
border: 1px solid #ccc;
padding: 6px 13px;
}

table tr {
border-top: 1px solid #ccc;
background-color: #fff;
}

table tr:nth-child(2n) {
background-color: #f8f8f8;
}

/* IMAGES
=============================================================================*/

img {
max-width: 100%
}
-->

pytho自动化开发 day01

Date:2016.01.09

    @南非波波

作者注：

    经过第一天的学习以及后续的代码练习,给自己一个约定的代码风格、格式：
    1. 模块名：
        模块应该使用尽可能短的、全小写命名，可以在模块命名时使用下划线以增强可读性。
        例如：
            login_shop.py
    2. 类名定义：
        由于类名要求首字母必须大写，所以这样定义：
        class MyFristClass:  # 类名有三个单词组成，分别首字母大写
            def __init__(self,a):
                pass
    3. 函数名定义：
        普通函数：
            选择使用字母小写，单词直接使用下划线_分割：
                shop_mag(users):
                    pass
    4. 变量名定义：
        全局变量名：
            字母全大写： SHOPLIST
        普通变量名：
            字母小写，单词分割选择使用首字母大写： shopUsers

以上规范并不是必须，但是作为个人的编程习惯而言，是一种很好的养成约束。

课程大纲地址： http://www.cnblogs.com/wupeiqi/articles/5115190.html

python知识拾忆：

Python2.x与Python3.x关于dict.keys()返回值的类型对比：

一、python种类

关于Python的一些版本内部执行的一些原理。从原理上来看待执行快慢的类型，从而选择自己需要的去学习。目前而言，最火的就是cpython了，这也是官方版本的Python。后面出现的pypy渐渐崭露头角，用银角大王的话讲：这货日后指定会火...

1. cpython  使用c解释器生产.pyc(字节码)，然后转换成机器码，最后到cpu
2. javapython java解释器-->字节码-->机器码-->cpu
3. IronPython C#解释器-->字节码 --> 机器码--> cpu
4. pypy  内部使用自己的解释器编译成字节码-->机器码.最后在外部执行的时候直接是机器码，速度要快

银角大王推荐阅读书：《python源码剖析》

二、字节码

在Python内部字节码直接的转换过程如图：

    python中进行字节码之间的转换流程大概是这样的：字节码类型转换从utf-8转换成gbk类型，首先需要执行解码变成Unicode类型，然后再由Unicode类型编码成gbk类型。[图片来源：银角大王课堂笔记]

三、字符串

博客链接：http://www.cnblogs.com/songqingbo/p/5126957.html

字符串的常用操作包括但不限于以下操作：

字符串的替换、删除、截取、复制、连接、比较、查找、分割等

这里将对字符串的内置操作方法进行总结归纳，重点是以示例的方式进行展示。

使用type获取创建对象的类 type(name)
使用dir获取类的成员dir(name)
使用vars获取类的成员和各个成员的值

capitalize

    功能：字符串首字母大写
    name = ‘swhthaitun‘
    name.capitalize()
    返回结果：‘Swht‘

casefold()首字母小写

    name = ‘HelloWord‘
    reault = name.casefold()
    print(reault)
    返回结果：helloword

casefold

    pass

center

    功能：字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串
    name = ‘swhthaitun‘
    name.center(15)
    返回结果：‘   swhthaitun  ‘ #默认以空格进行填充
    name.center(16,‘*‘)
    返回结果：‘***swhthaitun***‘

    功能：字符串居中，以‘*’分割(20为新产生字符串的总的宽度)
    name = ‘HelloWord‘
    reault = name.center(20,‘*‘)
    print(reault)
    返回结果：*****HelloWord******

count

    功能：统计某个字符在字符串中出现的次数，或在字符串指定区间内完成上述操作
    name = ‘swhthaitun‘
    name.count(‘h‘)
    返回结果：2
    name.count(‘h‘,0,3)  #从索引值0-3范围的字符中统计‘h‘出现的次数
    返回结果：1

    功能：统计子序列出现的次数
    name = ‘HelloWord‘
    reault = name.count(‘W‘) #如果换成‘w‘，返回结果为0，python对大小写敏感
    print(reault)
    返回结果：1

    name = ‘HelloWord‘
    reault = name.count(‘l‘,0,3) #统计单个字符出现的次数,可以指定起始范围,另外在python中起始范围讲究顾头不顾尾的原则，即[0,3)
    print(reault)

encode

    功能：对字符串进行编码操作
    name = ‘swhthaitun‘
    name.encode()
    返回结果：b‘swhthaitun‘

    功能：转变字符串的编码
    name = ‘南非波波‘
    reault = name.encode(‘gbk‘)
    print(reault)
    返回结果：b‘\xc4\xcf\xb7\xc7\xb2\xa8\xb2\xa8‘

endswith

    功能：判断字符串是否以某个字符串结尾的，返回值为bool型
    name = ‘swhthaitun‘
    name.endswith(‘s‘)
    返回结果：False
    name.endswith(‘n‘)
    返回结果：True
    name.endswith(‘tun‘)
    返回结果：True

    name = ‘Iamalatterboy‘
    reault = name.endswith(‘y‘)
    print(reault)
    返回结果：True

expandtabs

    功能：将制表符‘\t‘转换成指定宽度的tab键分割，默认tabsize=8
    li = ‘sw\tht‘
    li.expandtabs(4)
    返回结果：‘sw  ht‘
    li.expandtabs()
    返回结果：‘sw      ht‘

find

    功能：在字符串中查找指定字符串，找不到时返回-1
    name = ‘swht‘
    name.find(‘s‘)
    返回结果：0
    name.find(‘h‘)
    返回结果：2

format

    功能：格式化输出字符串
    li = ‘I\‘m {},{}‘ #两个‘{}‘是占位符
    li.format(‘swht‘,‘欢迎来中国‘)
    返回结果："I‘m swht,欢迎来中国"
    参考：http://blog.chinaunix.net/uid-23802873-id-4477364.html

_contains_

    功能：包含 -->‘eal‘ in name
    name = ‘swhtkkskjj‘
    reault = name.__contains__(‘swht‘)
    print(reault)
    返回结果：True

index

    功能：在字符串中查找指定的字符串,找不到时直接报错
    name = ‘swhthaitun‘
    name.index(‘w‘)
    返回结果：1

join()

    功能：字符串连接
    name = ‘swhthaitun‘
    ‘*‘.join(name)
    返回结果：‘s*w*h*t*h*a*i*t*u*n‘

isalnum

    功能：检查判断字符串是否包含字母数字字符（http://www.yiibai.com/python/string_isalnum.html）
    name = ‘swhthaitun‘
    name.isalnum()
    返回结果：True

isalpha

    功能：检测字符串是否只由字母组成（http://www.runoob.com/python/att-string-isalpha.html）
    name = ‘swhthaitun‘
    name.isalpha()
    返回结果：True

isdecimal

    功能：检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。（参考：http://www.runoob.com/python/att-string-isdecimal.html）
    name = ‘swhthaitun‘
    name.isdecimal()
    返回结果：False

isdigit

    功能：检测字符串是否只由数字组成。(参考:http://www.runoob.com/python/att-string-isdigit.html)
    name = ‘swhthaitun‘
    name.isdigit()
    返回结果：False

isidentifier

    功能：检测字符串是否是字母开头
    name = ‘swhthaitun‘
    name.isidentifier()
    返回结果：True
    name = ‘1swhthaitun‘
    name.isidentifier()
    返回结果：False

isnumeric

    功能：检测字符串是否只由数字组成。这种方法是只针对unicode对象。
    name = ‘swhthaitun‘
    name.isnumeric()
    返回结果：False
    Li = ‘5523‘
    Li.isnumeric()
    返回结果：True

isprintable

    功能：判断字符串中所有字符是否都属于可见字符
    a = "\tPuppy"
    a.isprintable()
    返回结果：False
    name = ‘swhthaitun‘
    name.isprintable()
    返回结果：True

isspace

    功能：检测字符串是否为空格
    name = ‘swhthaitun‘
    name.isspace()
    返回结果：False
    Li = ‘ ‘
    Li.isspace()
    返回结果：True

istitle

    功能：判断字符串是否适合当作标题（其实就是每个单词首字母大写）
    a = "a puppy"
    b = "Puppy"
    a.istitle()
    返回结果：False
    b.istitle()
    返回结果：True

isupper

    功能：判断字符串中所有字母字符是否都是大写字母
    a = "puppy"
    b = "PUPPY"
    a.isupper()
    返回结果：False
    b.isupper()
    返回结果：True

ljust

    功能：返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。（参考：http://www.runoob.com/python/att-string-ljust.html）
    语法：str.ljust(width[, fillchar])
         width -- 指定字符串长度。
         fillchar -- 填充字符，默认为空格。
    name = ‘swhthaitun‘
    name.ljust(50,‘*‘)
    返回结果：‘swhthaitun****************************************‘

lower

    功能：将所有的字母转换成小写字母
    name = ‘SWHT‘
    name.lower()
    返回结果：‘swht‘

lstrip

    功能：去除字符串左边开头的空格
    name = ‘  swht   ‘
    name.lstrip()
    返回结果：‘swht   ‘

rstrip

    功能：去除字符串右边结尾的空格
    name = ‘  swht   ‘
    name.rstrip()
    返回结果：‘   swht‘

strip

    功能：去除字符串两边的空格
    name = ‘  swht   ‘
    name.rstrip()
    返回结果：‘swht‘

maketrans

    功能：用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
    注：两个字符串的长度必须相同，为一一对应的关系。
    语法：str.maketrans(intab, outtab)
    参数：intab -- 字符串中要替代的字符组成的字符串。
          outtab -- 相应的映射字符的字符串。
    intab = "swhtr"
    outtab = "12345"
    name = "hjjksknsnjmk"
    name.maketrans(intab, outtab)
    返回结果：{104: 51, 114: 53, 115: 49, 116: 52, 119: 50}

partition

    功能：根据指定的分隔符将字符串进行分割。
        如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
    name = ‘swht‘
    li = ‘hhsslswhtolljm‘
    li.partition(name)
    返回结果：(‘hhssl‘, ‘swht‘, ‘olljm‘)

replace

    功能：把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
    语法：str.replace(old, new[, max])
    参数：old -- 将被替换的子字符串。
         new -- 新字符串，用于替换old子字符串。
         max -- 可选字符串, 替换不超过 max 次
    str = "this is string example....wow!!! this is really string"
    str.replace("is", "was")
    返回结果：‘thwas was string example....wow!!! thwas was really string‘
    str.replace("is", "was", 3)
    返回结果：‘thwas was string example....wow!!! thwas is really string‘

split

    功能：字符串分割，默认是空格
    name.split()
    返回结果：[‘swht‘]
    name.split(‘s‘) #以‘s‘字符进行分割
    返回结果：[‘‘, ‘wht‘]

_add_

    功能：在字符串后面增加指定的字符或字符串
    name = ‘swht‘
    name.__add__(‘e‘)
    返回结果：‘swhte‘
    li = ‘hjh‘
    name.__add__(li)
    返回结果：‘swhthjh‘

_contains_

    功能：判断指定字符串是否包含在字符串中,返回值为True和False
    name = ‘swht‘
    name.__contains__(‘s‘)
    返回结果：True

_eq_

    功能：判断字符串是否相等，返回值为True和False
    name = ‘swht‘
    li = ‘test‘
    name.__eq__(li)
    返回结果：False

四、列表

博客链接：http://www.cnblogs.com/songqingbo/p/5126943.html

列表的基本操作示例展示：

append

    功能：列表追加元素
    name = [‘sd‘,‘dfdf‘,‘drer‘]
    name.append(‘sdsd‘)
    返回结果：name
            [‘sd‘, ‘dfdf‘, ‘drer‘, ‘sdsd‘]

clear

    功能：情况列表元素
    name = [‘sd‘,‘dfdf‘,‘drer‘]
    name.clear()
    返回结果：name
             []

copy

    功能：浅拷贝，即只拷贝第一层的元素
    name = [‘sd‘,‘dfdf‘,‘drer‘]
    li = [‘ssd‘]
    li = name.copy()
    返回结果：li
             [‘sd‘, ‘dfdf‘, ‘drer‘]

    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    li = [‘ssd‘]
    li = name.copy()
    返回结果：li
    [‘sd‘, ‘dfdf‘, ‘drer‘, [‘sddss‘, ‘sdsdsd‘]]

count

    功能：统计列表指定元素个数
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.count(‘sd‘)
    返回结果：1
    li = [‘sd‘,‘sdsds‘,[‘sd‘,‘dffdg‘,],]
    li.count(‘sd‘) #只统计第一层的元素个数
    返回结果：1

extend

    功能：追加字符元素或列表元素
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    li = [‘sd‘,‘sdsds‘,[‘sd‘,‘dffdg‘,],]
    name.extend(‘ss‘)
    返回结果：name
    [‘sd‘, ‘dfdf‘, ‘drer‘, [‘sddss‘, ‘sdsdsd‘], ‘s‘, ‘s‘]
    name.extend(‘d‘)
    返回结果：name
    [‘sd‘, ‘dfdf‘, ‘drer‘, [‘sddss‘, ‘sdsdsd‘], ‘s‘, ‘s‘, ‘d‘]
    name.extend(li)
    返回结果：name
    [‘sd‘, ‘dfdf‘, ‘drer‘, [‘sddss‘, ‘sdsdsd‘], ‘s‘, ‘s‘, ‘d‘, ‘sd‘, ‘sdsds‘, [‘sd‘, ‘dffdg‘]]

index

    功能：定位列表中某元素
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.index(‘sd‘)
    返回结果：0
    name.index(‘drer‘)
    返回结果：2
    返回结果：name.index(‘dr‘)  #当出现某元素不在列表中的时候会直接报错
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            ValueError: ‘dr‘ is not in list

insert

    功能：在指定索引位置的元素前面插入新的元素
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.insert(3,‘sd‘)
    返回结果：name
    [‘sd‘, ‘dfdf‘, ‘drer‘, ‘sd‘, [‘sddss‘, ‘sdsdsd‘]]

pop

    功能：删除指定索引值的元素,返回值为当前删除的元素的值。不指定索引值，默认删除最后一个元素
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.pop(3)
    返回结果：‘sd‘

remove

    功能：删除列表中指定的元素
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.remove(‘sd‘)
    name
    返回结果：[‘dfdf‘, ‘drer‘, [‘sddss‘, ‘sdsdsd‘]]

reverse

    功能：用于反向列表中元素。
    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.reverse()
    name
    返回结果：[[‘sddss‘, ‘sdsdsd‘], ‘drer‘, ‘dfdf‘, ‘sd‘]

sort

    功能：对单层列表进行元素的排序
    name = [‘sd‘,‘dfdf‘,‘drer‘,]
    name.sort()
    name
    返回结果：[‘dfdf‘, ‘drer‘, ‘sd‘]

    name = [‘sd‘,‘dfdf‘,‘drer‘,[‘sddss‘,‘sdsdsd‘]]
    name.sort() #报错的
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>

五、元组

关于元组的常用操作，请参考：http://www.runoob.com/python/python-tuples.html

博客链接：http://www.cnblogs.com/songqingbo/p/5126947.html

元组的元素不可修改 ，元组的元素的元素可修改

count(self,value)

    功能：统计当前元组中某元素的个数
    tup = (55,77,85,55,96,99,22,55,)
    tup.count(55)
    返回结果：3
    备注：元素‘55’在元组tup中出现了3次

index(self, value, start=None, stop=None)

    功能：获取元素在元组中的索引值,对于重复的元素,默认获取从左起第一个元素的索引值
    tup = (55,77,85,55,96,99,22,55,)
    tup.index(55)
    返回结果：0
    tup.index(85)
    返回结果：2
    tup.index(55,2,7)
    返回结果：3

_add_

    功能：将另一个元组追加到当前元组后面.__add__()只接收元组类型的序列
    tup1 = (12,33,566,78,)
    tup2 = (55,66,77,)
    tup1.__add__(tup2)
    返回结果：(12,33,566,78,55,66,77,)

_contains_

    功能：包含，判断某元素是否包含在元组中
    tup = (55,77,85,55,96,99,22,55,)
    tup.__contains__(55)
    返回结果：True
    备注：返回值类型是bool型，该方法判断在对成员元素是否存在元组中，程序根据返回不同的bool值进行相应的值返回或者操作

_eq_

    功能：判断两个元组是否相等，返回值类型为bool型
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__eq__(tup1)
    返回结果：False

_getattribute_

    pass

_getitem_

    功能：获取指定索引值的元素值
    tup = (55,77,85,55,96,99,22,55,)
    tup.__getitem__(5)
    返回结果：99

_getnewargs_

    功能：只是获取原来的元组？？无卵用
    tup = (55,77,85,55,96,99,22,55,)
    tup.__getnewargs__()
    返回结果：((55, 77, 85, 55, 96, 99, 22, 55),)

_ge_

    功能：判断当前元组是否大于等于某个元组
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__ge__(tup1)
    返回结果：False #bool类型

_gt_

    功能：判断当前元组是否大于某个元组
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__ge__(tup1)
    返回结果：False #bool类型

_hash_

    功能：计算元组的hash值
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__hash__()
    返回结果：-2123087613
    tup1.__hash__()
    返回结果：1338854611

_init_

    功能：初始化作用，无返回值

_iter_

    功能：获取元组的内存地址
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__iter__()
    返回结果：<tuple_iterator object at 0x01C21F70>
    tup1.__iter__()
    返回结果：<tuple_iterator object at 0x01C21F50>

_len_

    功能：获取元组的长度
    tup.__len__()  #该方法已经被放到python的内置函数中，可以使用len(tup)获取长度
    返回结果：8

_le_

    功能：判断当前元组是否小于等于某个元组
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__le__(tup1)
    返回结果：True #bool类型

_lt_

    功能：判断当前元组是否小于某个元组
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__lt__(tup1)
    返回结果：True #bool类型

_mul_

    功能：把当前元组按照某个值的倍数进行元组的扩展，产生新的元组
    tup = (55,77,85,55,96,99,22,55,)
    tup.__mul__(2)
    返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)
    tup.__iter__()
    返回结果：<tuple_iterator object at 0x01C21F70>
    tup.__mul__(2).__iter__()
    返回结果：<tuple_iterator object at 0x01C2F050>

_new_

    pass

_ne_

    功能：判断当前元组不等于某个元组
    tup = (55,77,85,55,96,99,22,55,)
    tup1 = (55,77,85,55,96,99,22,551,)
    tup.__ne__(tup1)
    返回结果：True #bool类型

_repr_

    功能：将元组转换成一个字符串
    tup = (55,77,85,55,96,99,22,55,)
    tup.__repr__()
    返回结果：‘(55, 77, 85, 55, 96, 99, 22, 55)‘
     type(tup.__repr__())
    返回结果：<class ‘str‘>

_rmul_

    功能：？？怎么感觉跟__mul__一个德行？？
    tup = (55,77,85,55,96,99,22,55,)
    tup.__rmul__(2)
    返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)

六、字典

博客链接：http://www.cnblogs.com/songqingbo/p/5127044.html

字典的常用操作：

clear

    功能：清空字典
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.clear()
    返回结果：dict_li
            {}

copy

    功能：浅拷贝
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.copy()
    返回结果：{‘age‘: ‘18‘, ‘users‘: ‘swht‘}
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,‘address‘:{‘sd‘:‘dz‘}}
    dict_li.copy()
    返回结果：{‘age‘: ‘18‘, ‘users‘: ‘swht‘, ‘address‘: {‘sd‘: ‘dz‘}}

fromkeys()

    功能：用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
    语法：dict.fromkeys(seq[, value]))
    参数：seq -- 字典键值列表。
         value -- 可选参数, 设置键序列（seq）的值。
    li = [‘users‘,‘age‘]
    dict_li = dict.fromkeys(li,‘swht‘)
    返回结果：dict_li
            {‘age‘: ‘swht‘, ‘users‘: ‘swht‘}

get

    功能：获取字典的value值
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.get(‘users‘)
    返回结果：‘swht‘

items

    功能：返回可遍历的(键, 值) 元组数组
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.items()
    返回结果：dict_items([(‘age‘, ‘18‘), (‘users‘, ‘swht‘)])

keys

    功能：获取字典可遍历的键
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.keys()
    返回结果：dict_keys([‘age‘, ‘users‘])

pop

    功能：删除字典中指定的键值
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.pop(‘age‘)
    返回结果：‘18‘

popitem

    功能：随机返回并删除字典中的一对键和值
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.popitem()
    返回结果：(‘age‘, ‘18‘)
    dict_li
    {‘users‘: ‘swht‘}

setdefault

    功能：查找键值，如果键不已经存在于字典中，将会添加键并将值设为默认值。
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_li.setdefault(‘ID‘,5)
    返回结果：5
    dict_li
    返回结果：{‘age‘: ‘18‘, ‘users‘: ‘swht‘, ‘ID‘: 5}

update

    功能：把指定字典的键值更新到当前字典中
    dict_li = {‘users‘:‘swht‘,‘age‘:‘18‘,}
    dict_ai = {‘address‘:‘山东‘}
    dict_li.update(dict_ai)
    dict_li
    返回结果：{‘age‘: ‘18‘, ‘users‘: ‘swht‘, ‘address‘: ‘山东‘}

values

    功能：获取字典的所有值
    dict_li = {‘age‘: ‘18‘, ‘users‘: ‘swht‘, ‘address‘: ‘山东‘}
    dict_li.values()
    返回结果：dict_values([‘18‘, ‘swht‘, ‘山东‘])

七、set集合

博客链接：http://www.cnblogs.com/songqingbo/p/5128066.html

set集合是一个无序且不重复的集合。
创建一个set集合：
    name = set(‘sdd‘)
    name
    返回结果：{‘d‘, ‘s‘}

add

    功能：增加集合元素
    name = {‘d‘, ‘s‘}
    name.add(‘d‘)
    name
    返回结果：{‘d‘, ‘s‘}
    name.add(‘sd‘)
    name
    返回结果：{‘sd‘, ‘d‘, ‘s‘}

clear

    功能：清空集合元素
    name = {‘d‘, ‘s‘}
    name.clear()
    name
    返回结果：{}

copy

    功能：浅拷贝
    name = {‘sd‘, ‘d‘, ‘s‘}
    li = name.copy()
    返回结果：li
            {‘sd‘, ‘d‘, ‘s‘}

difference

    name.difference(li)
    set()
    >>> name.difference()
    {‘sd‘, ‘d‘, ‘s‘}

difference_update

    功能：删除当前set中的所有包含在 new set 里的元素
    li = (‘s‘, ‘d‘)
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.difference_update(li)
    name
    返回结果：{‘sd‘}

discard

    功能：移除元素
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.discard(‘s‘)
    返回结果：name
            {‘sd‘, ‘d‘}

intersection

    功能：取交集,建立新的set集合
    li = (‘s‘, ‘d‘)
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.intersection(li)
    返回结果：{‘d‘, ‘s‘}

intersection_update

    功能：取交集,更新原来的set集合
    li = (‘s‘, ‘d‘)
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.intersection_update(li)
    返回结果：{‘d‘, ‘s‘}

isdisjoint

    功能：判断没有交集，返回True,否则,返回False
    li = {‘s‘, ‘d‘}
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.isdisjoint(li)

issubset

    功能：判断是否是子集
    li = {‘s‘, ‘d‘}
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.issubset(li)  #判断name是不是li的子集
    返回结果：False
    li.issubset(name)  #判断li是不是name的子集
    返回结果：True

issuperset

    功能：判断是否是父集
    li = {‘s‘, ‘d‘}
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.issubset(li)  #判断name是不是li的父集
    返回结果：True
    li.issubset(name)  #判断li是不是name的父集
    返回结果：False

pop

    功能：移除集合元素
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.pop(‘s‘)
    返回结果：‘sd‘ #从左侧删除收个

remove

    功能：移除指定集合元素
    name = {‘sd‘,‘d‘,‘s‘}
    name.remove(‘s‘)
    返回结果：name
    {‘sd‘, ‘d‘}

symmetric_difference

    功能：去两个集合的差集，建立新的set集合对象
    name = {‘sd‘, ‘d‘, ‘s‘}
    li = {‘s‘, ‘d‘}
    name.symmetric_difference(li)
    返回结果：{‘sd‘}

symmetricdifferenceupdate

    功能：去两个集合的差集，更新原来的集合对象
    name = {‘sd‘, ‘d‘, ‘s‘}
    li = {‘s‘, ‘d‘}
    name.symmetric_difference_update(li)
    返回结果：{‘sd‘}

union

    功能：并集，创建新的对象
    name = {‘sd‘, ‘d‘, ‘s‘}
    li = {‘s‘, ‘d‘,‘h‘}
    name.union(li)
    返回结果：{‘h‘, ‘s‘, ‘d‘, ‘sd‘}

update

    功能：更新已有集合
    name = {‘sd‘, ‘d‘, ‘s‘}
    name.update(‘df‘)
    name
    返回结果：{‘sd‘, ‘d‘, ‘f‘, ‘s‘}

八、类与对象

对象

python中一切事物皆对象,对象是一开始就有的,只是我们无法访问它。访问对象需要以变量的形式去访问（即创建变量指向到对象的，变量即对对象的引用）
在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）
结论：对象=属性+方法

类

在python中，把具有相同属性和方法的对象归为一个类（class）
比如人类，动物，植物等等，这些都是类的概念。
类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
类包含描述对象的方法。

int

取绝对值：
    age = -19
    age.__abs__() #int类函数调用
    abs(-19) #内置函数方式操作
取商和余数：
    age = 95
    age.__divmod__(10) #95/10 -->(9,5)
相加：
    a = 5，b=6
    a.__add__(b) #调用int的类函数add，相当于a + b  -->11
    a + b #内置函数方式操作

作业：

1. 博客整理
2. 购物商城实现
    1. 商品展示，价格
    2. 购物车添加商品（进行差异商品，同一种商品应该只存在一条数据）
    3. 付款（根据钱进行判断是否可以满足付款）
3. 预习
    http://www.cnblogs.com/wupeiqi/articles/5115190.html  后面的部分
时间： 2024-10-17 09:10:47

python开发学习-day02(元组、字符串、列表、字典深入)的相关文章

python开发学习日记01(字符串)

时间:2018/12/16 作者:永远的码农(博客园) 环境: win10,pycharm2018,python3.7.1 1.1  基础操作(交互输入输出) 1 input = input("请输入一个字符串:") 2 print("你输入的字符串是:",input) 执行结果: 请输入一个字符串:python 你输入的字符串是: python 1.2  字符串索引和分片 1 stu = "hello python"#索引的使用,跟数组一样的语

day5_python学习笔记_chapter6_字符串列表元组

1. 序列:seq[n], seq[x:y], seq * n序列重复n次,切片, 序列翻转 s="abcde", s[::-1]="edcba" 内建函数:1. 类型转换: list(iter), str(obj), unicode(obj), tuple(iter) , 2. len(seq), max(), min() , reversed(), sorted(), sum(), 2. 字符串: in ,not in ,,, import string , s

3. 蛤蟆Python脚本学习笔记三字符串

3. 蛤蟆Python脚本学习笔记三字符串 本篇名言:"平静的湖面只有呆板的倒映,奔腾的激流才有美丽的浪花!幸福不是靠别人来布施,而是要自己去赢取!生命的意义在不断挑战自己,战胜自己!" 这个本来放在昨天的,由于昨晚又太晚了,所以就搁在这里了.赶紧看看吧. 字符串两边都用双引号或者单引号包起来.否则就使用转移符号来转移一下. 输入在一起可以直接拼接. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/48112507

Python使用eval强制转换字符串为字典时报错：File &quot;&lt;string&gt;&quot;, line 1, in &lt;module&gt; NameError: name &#39;nan&#39; is not defined

文本中保存的内容为: { 'QQQ': [0.067, 0.167, 0.2, 0.033, 0.233, 0.267, 0.1, 0.133], 'TTT': [0.5, 0.375, 0.25, 0.3, 0.6, 0.333, 0.857, 0.636, 0.667, 0.556] } 用eval转换为字符串时报错: File "test.py", line 43, in d1 data = eval(infile.readline()) File "<strin

Python支持多重继承吗？Python开发学习

Python支持多重继承吗?Python开发学习 继承是面向对象编程的一个重要方式,通过继承,子类可以扩展父类的功能,Python也具有该特性,除此之外,Python还可以使用多重继承. 语法: class subClass(Base1,Base2) 该语法的含义是创建了一个subClass类,让它同时继承了Base1和Base2的相关特性,关于继承还有以下规则需要遵循: 1. 继承只会继承父类的方法,不能继承父类的变量: 2. 要想继承父类的变量,需要执行父类的__init__(self)方法

Python学习笔记#元组和列表的区别

python的基本类型中有元组和列表这么俩个,但是这哥俩却比较难于区分,今天就来用简单的实例说明两者的不同. 列表:1.使用中括号([ ])包裹,元素值和个数可变 实例: aaa = ['sitename','www','pythontab','com'] 元组:1.使用中括号(())包裹,不可以被更改(尽管他们的内容可以) bbb = ['sitename','www','pythontab','com'] 元组可以看成是 只读 的列表 两者都可以通过[:]得到子集,和字符串使用方法相同 下例

Python的学习之旅———基本数据类型(字典)

作用:存多个值,key-value存取,取值速度快 定义:key必须是不可变类型,value可以是任意类型d={[1,2,3]:1} #列表不能当做字典的keyd={(0,'mac'):3000} 元组可以是 字典 举例info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....}) 优先掌握的操作:按key存取值:可存可取print(info['sex'])info['hobbies']=['read','music','play'

Python开发学习路线

Python , 是一种面向对象的解释型计算机程序设计语言,具有丰富和强大的库,Python 已经成为继JAVA,C++之后的的第三大语言. 特点:简单易学.免费开源.高层语言.可移植性强.面向对象.可扩展性.可嵌入型.丰富的库.规范的代码.大这里给家列出从Python入门到实战学习路线. 一.入门教程 1.Python 面向对象编程 2.jquery入门 3.HTML+CSS基础入门 4.Javascript初步 5.Python语言编程基础 二.初级教程 1.Git 与 GitHub 2.P

python数据类型基础总结（字符串 列表 元组 字典 集合 ）

字符串: 有序.不可变数据类型,支持索引,切片,步长(字符串中的每一个字母或字符都称为元素) 索引(下标):通过索引精确定位到每个元素 索引从左开始向右排 从0开始 索引时不能超过最大值,超出报错 从右向左排从-1开始 切片(顾头不顾尾) 步长 print(name[::2] 取整个字符串,步长为2 字符串方法: upper 全部大写 lower全部小写 capitalize 首字母大写 title每个单词的首字母大写 swapcase 大小写转换 starswith 以..开头 endswit