python之数据结构

目录

一、数据结构的基本类型

二、数字(number)

三、字符串

四、列表

五、元组

七、集合

八、布尔：Ture、False

九、None

十、文件

十一、时间格式

---

一、数据结构的基本类型

1.可变数据类型(不可哈希类型)：可以在存储id不变的情况下，改变数据类型的值，亦为不可哈希类型，不可哈希，不可作为字典的key

列表(list)，字典(dict)，集合(set)

不可变数据类型(可哈希类型):并非指数据的值不可变，而是改变数据值的实质是形成列一个新的数据，其存储id是改变的，亦为哈希类型，可哈希，可以作为字典的key

    # Python中的真假值含义：1. 数字如果非零，则为真，0为假。 2. 其他对象如果非空，则为真
    # 通常意义下的类型分类：1. 数字、序列、3映射。 2. 可变类型和不可变类型

数字(int,float,complex,decimal,fraction)，字符(str,bytes)，元组(tuple)，冻结集合(frozenset)，None，bool(True,False)

>>> a=1
>>> id(a)
42283352
>>> a+=1#"a+=1"同"a=a+1",但不会改变其id
>>> id(a)
42283328
>>> a=[1,2]
>>> id(a)
140480671529656
>>> a+=[3]
>>> id(a)
140480671529656

2.测试数据类型的三种方法，推荐第三种

L=[1,2,3]
if type(L) == type([]):
    print("L is list")
if type(L) == list:
    print("L is list")
if isinstance(L, list):
    print("L is list")

3.动态类型

 变量名通过引用，指向对象。
 Python中的“类型”属于对象，而不是变量，每个对象都包含有头部信息，比如"类型标示符" "引用计数器"等

3.1共享引用及在原处修改：

对于可变对象，要注意尽量不要共享引用！

>>> L=[1]
>>> M=[1]
>>> id(L)
139901251999880
>>> id(M)
139901252003784
>>> L is M
False
#=================================================================
>>> L=M=[1]
>>> id(L)
139901252003336
>>> id(M)
139901252003336
>>> L is M
True

3.2    增强赋值和共享引用：

普通+号会生成新的对象，而增强赋值+=会在原处修改

>>> l=m=[1,2]
>>> id(l)
139901252003784
>>> id(m)
139901252003784
>>> l=l+[3]           #普通+号
>>> id(l)
139901252004040
>>> m+=[3]            #增强赋值
>>> id(m)
139901252003784

 

二、数字(number)

整型(int)、浮点型(float)、复数(complex)，十六进制(Hexadecimal)，十进制(decimal),八进制(octal),二进制(binary),分数(fraction)

1.数字常量及类型转换

整数:1234, -1234, 0, 999999999
浮点数:1.23, 1., 3.14e-10, 4E210, 4.0e+210
八进制，十六进制，二进制:0o177, 0x9ff, 0X9FF, 0b101010
复数:3+4j, 3.0+4.0j, 3J

#类型转换
>>> int(20.1)#浮点转整数
20
>>> float(20)#整数转浮点
20.0
>>> complex(20)#整数转复数
(20+0j)
>>> complex(2.3,2.1)#浮点转复数
(2.3+2.1j)
>>> hex(10)#十进制转十六进制
'0xa'
>>> oct(10)#十进制转八进制
'0o12'
>>> bin(10)#十进制转二进制
'0b1010'
>>> int('0xa',base=16)#十六进制转整数
10

2.数字操作符

>>> 1+2#加
3
>>> 2-1#减
1
>>> 2*3#乘
6
>>> 5/3#除
1.6666666666666667
>>> 5//3#取除后(商)的整数部分
1
>>> 5.0//3#取除后(商)的整数部分，分子是浮点型，则结果也是浮点
1.0
>>> 5**2#幂：5的二次方
25
>>>100**0.5#开方：100的开二次根号
10.0
>>> 5%3#取除后的四舍五入后的整数
2
# 生成器函数发送协议    yield x                                      
# 生成匿名函数    lambda args: expression                      
# 三元选择表达式    x if y else z                                
# 逻辑与、逻辑或、逻辑非    x and y, x or y, not x                       
# 成员对象测试    x in y, x not in y                           
# 对象实体测试    x is y, x is not y                           
# 大小比较，集合子集或超集值相等性操作符    x<y, x<=y, x>y, x>=y, x==y, x!=y             
# Python中允许连续比较    1 < a < 3                                    
# 位或、位与、位异或    x|y, x&y, x^y                                
# 位操作：x左移、右移y位    x<<y, x>>y                                   
# 真除法、floor除法：返回不大于真除法结果的整数值、取余、幂运算    +, -, *, /, //, %, **                        
# 一元减法、识别、按位求补（取反）    -x, +x, ~x                                   
# 索引、分片、调用    x[i], x[i:j:k]                               
 

3.变量：_

#表达式最后所得的值被赋值给变量_，_ 变量应被用户视为只读变量。
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

4.数学函数

#求和，最大值，最小值，参数需要为可迭代类型
>>> sum(123)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> sum('123')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> sum([1,2,3])
6
>>> max(123)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> max(1,2，3)
3
>>> max("abc")
'c'
>>> min('abc')

#返回数字的绝对值，整数
>>> abs(-10)
10
#返回数字的绝对值，浮点数
>>> type(math.fabs(-10))
<class 'float'>
>>> math.fabs(-10)
10.0
#返回浮点数的四舍五入值:round(x,n)n指四舍五入到小数点后的第几位
>>> round(10.5)
10
>>> round(10.6)
11
>>> round(10.6666,2)
10.67
#返回数字的上入整数，math模块函数
>>> math.ceil(5.1)
6
#返回数字的下舍整数，math模块函数，同内建函数int()
>>> math.floor(4.9)
4
#开平方
>>>math.sqrt(100)
10.0

5.随机函数

#需要使用到random模块
>>> import random
#随机选择
>>> random.choice(range(10))
7
>>> random.choice(range(10))
1
#从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
#randrange ([start,] stop [,step])
start -- 指定范围内的开始值，包含在范围内。
stop -- 指定范围内的结束值，不包含在范围内。
step -- 指定递增基数。如1为所有数字，2为奇数
>>> random.randrange(1,10)
6
#随机生成一个实数，在(0,1)的范围，不包含1

>>> random.random()
0.7270227894366981
>>> random.random()
0.42049921371667365

#随机生存一个实数，在(x,y)的范围，不包含y

>>> random.uniform(1,3)
2.3586820013397682
>>> random.uniform(1,3)
1.1346213127429607
#shuffle() 方法将序列的所有元素随机排序。不能用于不可变类型
>>> a=[1,2,3,4]
>>> random.shuffle(a)
>>> a
[4, 3, 1, 2]
>>> a
[4, 3, 1, 2]
>>> b=(1,2,3,4)
>>> random.shuffle(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\lib\ra
dom.py", line 278, in shuffle
    x[i], x[j] = x[j], x[i]
TypeError: 'tuple' object does not support item assignment

6.数字相关模块

import math            #数字模式
import decimal         #小数模式
from decimal import Decimal       #小数模式
from fractions import Fraction    #分数模式
import random          #随机数模式
Decimal("0.01") + Decimal("0.02")        # 返回Decimal("0.03")
decimal.getcontext().prec = 4            # 设置全局精度为4 即小数点后边4位
x = Fraction(4, 6)                       # 分数类型 4/6
x = Fraction("0.25")                     # 分数类型 1/4 接收字符串类型的参数

7.整数可以利用bit_length函数测试所占的位数
    a = 1;       a.bit_length()    # 1
    a = 1024;    a.bit_length()    # 11

三、字符串

字符串为不可变类型，可哈希、但是序列类型，可迭代

字符串常量

    S = ''                                  # 空字符串
    S = "spam’s"                            # 双引号和单引号相同
    S = "s\np\ta\x00m"                      # 转义字符
    S = """spam"""                          # 三重引号字符串，一般用于函数说明
    S = r'\temp'                            # Raw字符串，不会进行转义，抑制转义
    S = b'Spam'                             # Python3中的字节字符串
    S = u'spam'                             # Python2.6中的Unicode字符串
    s1+s2, s1*3, s[i], s[i:j], len(s)       # 字符串操作
    'a %s parrot' % 'kind'                  # 字符串格式化表达式
    'a {1} {0} parrot'.format('kind', 'red')# 字符串格式化方法
    for x in s: print(x)                    # 字符串迭代，成员关系
    [x*2 for x in s]                        # 字符串列表解析
    ','.join(['a', 'b', 'c'])               # 字符串输出，结果：a,b,c

 

1.访问字符串的值和表达式

#可迭代
>>> a="a,b,c,d"
>>> for i in a:
...     print(i)
...
a
,
b
,
c
,
d
#切片
>>> a[1:2]
','

2.拼接&切片

>>> a="abc"
>>> b="def"
>>> a+b
'abcdef'
>>> a*2
'abcabc'
#拼接
>>> a="wang"  "home"
>>> print(a)
wanghome
>>> a="wang"\
... 'home'
>>> print(a)
wanghome
  
#不可变类型
>>> a='hello world'
>>> a[:6]+"rooby"
'hello rooby'
>>> a
'hello world'
#切片
>>> s='abcdefghijk'
>>> s[1:10:3]    #第三个参数表示步长
'beh'

3.转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

转义字符	描述
\	续行符
\a	响铃
\b	退格符backspace
\000	空值
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	翻页

 

 

 

 

 

 

 

 

 

 

>>> a='abcdefg\nhijklmn'
>>> print(a)
abcdefg
hijklmn

4.原始字符串:r/R

原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串,所以不用加u

5.字符串格式化

5.1格式化方式

    基于C语言的'print'模型，并且在大多数的现有的语言中使用。
    通用结构：%[(name)][flag][width].[precision]typecode

#普通格式化%s
>>> st="我叫 %s 今年 %d 岁!" % ('小明', 10)
>>> print(st)
我叫 小明 今年 10 岁!
#普通格式化%d
>>> s="%d"%(1)
>>> s
'1'
# 对齐方式及填充：
"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234)         
"1234...  1234...1234  ...001234"
#基于字典的格式化方式:
>>> a='%(name1)d%(name2)d'%{'name1':2,'name2':2}
>>> print(a)
22
#vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量
>>> a="%(__name__)s is %(__builtins__)s" % vars()
>>> print(a)
__main__ is <module 'builtins' (built-in)>

#%c
>>> s="%c"%('2.3333')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: %c requires int or char
>>> s="%c"%('a')
>>> s
'a'
>>> s="%c"%('1')
>>> s
'1'

格式化符号	描述
%s	格式化字符串
%d	格式化整数
%c	格式化字符串或ASCII码
*	定义宽度或小数点精度
-	左对齐

 

 

 

 

 

 

 

5.2格式化方法format()

# 普通调用
"{0}, {1} and {2}".format('spam', 'ham', 'eggs')            # 基于位置的调用
"{motto} and {pork}".format(motto = 'spam', pork = 'ham')   # 基于Key的调用
>>> a="{motto} and {0}".format('ham', motto = 'spam')       # 混合调用
>>> print(a)
spam and ham
# 添加键、属性、偏移量 (import sys)
>>> import sys
>>> "my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'})# 基于位置的键和属性
'my laptop runs linux' 
>>> "{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'})
'laptop linux'                                                # 基于Key的键和属性
>>> "first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基于位置的偏移量
'first = A, second = B'
#具体格式化
"""
{fieldname:format_spec}".format(......)
    # 说明:
        fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
        format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
        fill        ::=  <any character>              #填充字符
        align       ::=  "<" | ">" | "=" | "^"        #对齐方式
        sign        ::=  "+" | "-" | " "              #符号说明
        width       ::=  integer                      #字符串宽度
        precision   ::=  integer                      #浮点数精度
        type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
    """
"{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159)   # 输出'3.141590e+00, 3.142e+00, 3.14159'
# 例子:
'={0:10} = {1:10}'.format('spam', 123.456)    # 空格填齐10字符'=spam       =    123.456'
'={0:>10}='.format('test')                    # 字符右边'=      test='
'={0:<10}='.format('test')                    # 字符左边'=test      ='
'={0:^10}='.format('test')                    # 字符中间'=   test   ='
'{0:X}, {1:o}, {2:b}'.format(255, 255, 255)   # 输出'FF, 377, 11111111'
'My name is {0:{1}}.'.format('Fred', 8)       # 输出'My name is Fred    .'  动态指定参数

 

6.字符串函数

6.1str.capitalizi() 将第一个字母变成大写

#capitalize()方法语法：str.capitalize()
>>> "abc".capitalize()
'Abc'

6.2center(width,fillchar)返回一个指定宽度的居中的字符串

center()方法语法：str.center(width[, fillchar])
参数
width -- 字符串的总宽度。
fillchar -- 填充字符。

>>> 'abc'.center(5,'1')
'1abc1'
>>> 'abc'.center(6,'1')
'1abc11'

6.3count()用于统计字符串里某个字符出现的次数

count()方法语法：str.count(sub, start= 0,end=len(string))
参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

>>> 'abc'.count('a')
1
>>> 'abc'.count('abc')
1

6.4encode()&decode()字符编码&解码

decode()方法语法：bytes.decode(encoding="utf-8", errors="strict")
encode()方法语法：str.encode(encoding='UTF-8',errors='strict')
参数
encoding -- 要使用的编码，如"UTF-8"。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

>>> a="我是谁"
>>> b=a.encode("UTF-8")
>>> C=A.encode("GBK")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'A' is not defined
>>> c=a.encode("GBK")
>>> print(a,b,c)
我是谁 b'\xe6\x88\x91\xe6\x98\xaf\xe8\xb0\x81' b'\xce\xd2\xca\xc7\xcb\xad'

>>> print(a.decode(UTF-8),b.decode(UTF-8),C.decode(GBK))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'decode'
>>> print(b.decode('UTF-8'),C.decode('GBK'))
我是谁 我是谁

6.6endswith() &startswith方法用于判断字符串是否以指定后缀结尾&开头，如果以指定后缀结尾返回True，否则返回False。

endswith()方法语法：str.endswith(suffix[, start[, end]])
参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。

>>> a="klfslkdhdlkfjdklfjdsklf"
>>> a.endswith('f')
True
>>> a.endswith('f',0,10)
False
>>> a.endswith('f',0,50)
True

6.7find() &rfind(从右边开始搜索)测字符串中是否包含子字符串 str,如果包含子字符串返回开始的索引值，否则返回-1

find()方法语法：str.find(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
>>> a.find('c',0,2)
-1
>>> a.find('a',0,2)
0

6.8index() 方法检测字符串中是否包含子字符串 str ,如果包含子字符串返回开始的索引值，否则抛出异常

index()方法语法：str.index(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
>>> a.index('c',0,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> a.index('b',0,2)
1
>>> a.index('a',0,2)
0

6.9isalnum如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

#如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
>>> str="abc2018"
>>> str.isalnum()
True
>>> b="abc"
>>> b.isalnum()
True
>>> b="abc."
>>> b.isalnum()
False

6.10 isalpha() 方法检测字符串是否只由字母组成。

#如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
>>> a='abc'
>>> b='abc1'
>>> a.isalpha()
True
>>> b.isalpha()
False

6.11 isdigit() ,同isnumeric()方法检测字符串是否只由数字组成。

#字符串只包含数字则返回True
>>> a="123"
>>> b="a123"
>>> a.isdigit()
True
>>> b.isdigit()
False

6.12islower()判断所有字符所有字符是否都是小写

>>> a='abc'
>>> a.islower()
True
>>> b='Abc'
>>> b.islower()
False

6.13isupper()判断是否全部字符为大写

>>> a='ABC'
>>> b='aBC'
>>> a.isupper()
True
>>> b.isupper()
False

 

6.14join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串

join()方法语法：str.join(sequence)
参数
sequence -- 要连接的元素序列。
>>> a='abc'
>>> b=[1,2,3]
>>> a.join(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found
>>> b=['1','2','3']
>>> a.join(b)
'1abc2abc3'

6.15len()返回字符串长度

>>>a='abc'
>>>len(a)
3

6.16ljust() &rjust()返回一个原字符串左&右对齐,并使用fillchar的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

ljust()方法语法：str.ljust(width[, fillchar])
参数
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。

>>> a='abc'
>>> a.ljust(10."s")
>>> a.ljust(10,"s")
'abcsssssss'

6.17lstrip()删除字符串左边的空格或指定字符

lstrip()方法语法：str.lstrip([chars])
参数
chars --指定截取的字符。

>>> a='abc'
>>> a.lstrip('a')
'bc'
>>> a='   bc'
>>> a.lstrip()
'bc'

6.18rstrip()删除字符串右边的空格或者指定字符

rstrip()方法语法：str.rstrip([chars])
参数
chars --指定截取的字符。
>>> a='abc'
>>> a.rstrip('c')
'ab'
>>> a='abc    '
>>> a.rstrip()
'abc'

 

6.19strip()执行lstrip(),rstrip(),删除两边的空格或者指定的字符

lstrip()方法语法：str.lstrip([chars])
参数
chars --指定截取的字符。
>>> a='abc'
>>> a.strip('a')
'bc'
>>> a='   abc   '
>>> a.strip()
'abc'

6.20lower()&upper()将字符串全部转换为小写字符&将字符串全部转换为大写字符

lower()方法语法：str.lower()
>>> a='ABc'
>>> a.lower()
'abc'
>>> a.upper()
'ABC'

6.21max() &min()方法返回字符串中最大的字母&最小字符

语法max()方法语法：
max(str)
参数
str -- 字符串。

>>> a='abc'
>>> max(a)
'c'
>>> min(a)
'a'

6.22replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

replace()方法语法：str.replace(old, new[, max])
参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

>>> a='abc'
>>> a.replace('a','sss')
'sssbc'

6.23split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

split()方法语法：str.split(str="", num=string.count(str))
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。
>>> a='abc'
>>> a.split('b')
['a', 'c']

>>> a='sad dksaj dasjkdl'
>>> a.split('',1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: empty separator
>>> a.split(' ',1)
['sad', 'dksaj dasjkdl']

6.24splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表

splitlines()方法语法：str.splitlines([keepends])
参数
keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
>>> a="""dksajdlkad
... dljasjdlskajdlk
... djlasjdlskadj
... jldksajdlskadj
... """
>>> a.splitlines()
['dksajdlkad', 'dljasjdlskajdlk', 'djlasjdlskadj', 'jldksajdlskadj']
>>> a.splitlines(False)
['dksajdlkad', 'dljasjdlskajdlk', 'djlasjdlskadj', 'jldksajdlskadj']
>>> a.splitlines(True)
['dksajdlkad\n', 'dljasjdlskajdlk\n', 'djlasjdlskadj\n', 'jldksajdlskadj\n']

2.25swapcase() 方法用于对字符串的大小写字母进行转换。

语法swapcase()方法语法：
str.swapcase();
>>> a='aBc'
>>> a.swapcase()
'AbC'

2.26title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写(见 istitle())。

title()方法语法：str.title();
>>> a='dsadsa dasdsa dsadasd'
>>> a.title()
'Dsadsa Dasdsa Dsadasd'

2.27ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常

语法ord(c)
参数
c -- 字符。
返回值是对应的十进制整数。
>>> ord('a')
97
>>> ord('b')
98
>>>ord('\x01')
1

2.28chr()函数是ord()函数的配对函数，由整数转换成一个字符

语法:chr(i)
参数
i -- 可以是10进制也可以是16进制的形式的数字。
返回值是整数对应的ascii&unicode字符(python3升级了支持unicode字符，并取消了unichr字符)
>>> chr(97)
'a'
>>> chr(98)
'b'
>>> chr(1)
'\x01'

2.29isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法isinstance(object, classinfo)
参数

object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
#=================如果判断str时抱错typeerror，退出python重进即可
>>> a='abc'
>>> b=123
>>> c=[1,2,3]
>>> isinstance(a,str)
True
>>> isinstance(b,str)
False
>>> isinstance(c,list)
True

6.30zfill()获取固定长度，右对齐，左边不足用0补齐

>>>str = "this is string example....wow!!!";
>>>print str.zfill(40);
>>>print str.zfill(50);

00000000this is string example....wow!!!
000000000000000000this is string example....wow!!!

6.31

 

 

四、列表

列表属于可变类型，序列类型，不可哈希

1.截取、新增、拼接

#切片截取
>>> a=[0,1,2,3,4,5,6,7,8,9,(1,2,3,4)]
>>> a[1]
1
>>> a[10][1]
2
>>> a[1:4]
[1, 2, 3]
#第三个参数为步长
>>> a[::2]    #偶数
[0, 2, 4, 6, 8, (1, 2, 3, 4)]
>>> a[1::2]
[1, 3, 5, 7, 9]    #奇数项
>>>a[:]#完全切片
[1,2,3,4,5,6,7,8,9,10]
#拼接
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a+b
[1,2,3,4,5,6]

2.更新列表

#可用索引表达式赋值的方法直接更新列表元素
>>> a=[1,2,3,4,5,6,7,8,9,10]
>>> a[0]='dkljaslkd'
>>> a
['dkljaslkd', 2, 3, 4, 5, 6, 7, 8, 9, 10]
#a=a+[]和a+=[]的区别
>>> a=[1,2,3]
>>> a+=[4,5,6]#a的id不会改变
>>> a
[1, 2, 3, 4, 5, 6]
>>> id(a)
140349316832264
>>> a=a+[6,7,8]#a的id改变，属于对a重新赋值，产生新的变量a
>>> a
[1, 2, 3, 4, 5, 6, 6, 7, 8]
>>> id(a)
140349324204360

2.删除列表

#del可以直接删除整个列表，也可以删除列表中元素
>>> a=[1,2,3]
>>> del a[1]
>>> a
[1, 3]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

#利用切片删除列表的元素
>>> a=[1,2,3,4]
>>> a[0:2]=[]
>>> a
[3, 4]

3.列表操作符：长度，组合，重复，成员关系符，迭代、列表解析

#长度
>>>len([1,2,3])
4
#list1+list2,list*2
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> c=a+b
>>> c
[1, 2, 3, 4, 5, 6]
>>> d=a*2
>>> d
[1, 2, 3, 1, 2, 3]
#迭代
>>> for i in [1,2,3]: print(i)
... 
1
2
3

#列表解析
>>> list(map(ord,'spam'))
[115, 112, 97, 109]
>>> list(map(lambda x:ord(x),'spam'))
[115, 112, 97, 109]

 

4.列表函数

1.sum()求和、max()最大、min()最小值

>>> int(10.8)
10
>>> sum([1,2,3,4])
10
>>> max([1,2,3,4])
4
>>> min([1,2,3,4])
1

2.len()列表长度

>>>len([1,2,3,4,5])
5

3.list()转换为列表

#将序列类型的元素转换为列表
>>> a="abc"
>>> list(a)
['a', 'b', 'c']

4.append()在列表末尾添加元素

append()方法语法：
list.append(obj)
参数
    obj -- 添加到列表末尾的对象。
返回值
该方法无返回值，但是会修改原来的列表。

>>> a=[1,2,3,4]
>>> b=a.append(5)
>>> print(b)
None
>>> print(a)
[1, 2, 3, 4, 5]

5.count()统计元素数量

count()方法语法：
list.count(obj)
参数
    obj -- 列表中统计的对象。
返回值
返回元素在列表中出现的次数。
>>> a=[1,2,3,3,4,5,3]
>>> a.count(3)
3

6.extend()用于在列表末尾一次性追加另一个序列中的多个值（同list1+list2）

extend()方法语法：
list.extend(seq)
参数
    seq -- 元素列表。
返回值
该方法没有返回值，但会在已存在的列表中添加新的列表内容。
>>> a=[1,2,3,4]
>>> b=[5,6,7,8]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

7.index()从列表中找出某个值第一个匹配项的索引位置。

index()方法语法：list.index(obj)
参数
    obj -- 查找的对象。
返回值
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

[1, 2, 3, 4, 5, 6, 7, 8]
>>> a.index(2)
1

8.insert() 函数用于将指定对象插入列表的指定位置。

insert()方法语法：list.insert(index, obj)
参数
    index -- 对象obj需要插入的索引位置。
    obj -- 要插入列表中的对象。
返回值
该方法没有返回值，但会在列表指定位置插入对象。
>>> a=[1,2,3,4]
>>> a.insert(0,1)
>>> a
[1, 1, 2, 3, 4]

9.pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

pop()方法语法：list.pop([index=-1])
参数
    index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
返回值
该方法返回从列表中移除的元素对象。
a=[1, 1, 2, 3, 4]
>>> a.pop()
4
>>> a
[1, 1, 2, 3]
>>> a.pop(0)
1
>>> a
[1, 2, 3]

10.remove() ,根据元素值，pop()根据元素索引函数用于移除列表中某个值的第一个匹配项。

remove()方法语法：list.remove(obj)
参数
    obj -- 列表中要移除的对象。
返回值
该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
>>>a=[1,2,3]
>>> a.remove(1)
>>> a
[2, 3]

11.reverse() 函数用于反向列表中元素。

reverse()方法语法：list.reverse()
参数
    NA。
返回值
该方法没有返回值，但是会对列表的元素进行反向排序。


>>> a=[4,2,3,1]
>>> a.reverse()
>>> a
[1, 3, 2, 4]

12.list.sort() &sorted(list)函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

#sort()方法语法：list.sort(cmp=None, key=None, reverse=False)
参数
    cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
    key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。


#sorted 排序，返回一个列表
    sort 与 sorted 区别：
    sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法
sorted(iterable, key=None, reverse=False)  
参数
    iterable -- 可迭代对象。
    key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
实例
>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]                      # 默认为升序

>>> a=[1, 3, 2, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a=[2,4,5,1,3]
>>> a.sort(reverse=True)
>>> a
[5, 4, 3, 2, 1]

13.clear() 函数用于清空列表，类似于 del a[:]。

clear()方法语法：list.clear()
参数
    无。
返回值
该方法没有返回值。
>>>a=[1,2,3]
>>>a.clear()

14.copy()

copy()方法语法：list.copy()
参数
    无。
返回值
返回复制后的新列表。
>>> a=[5, 4, 3, 2, 1]
>>> b=a.copy()
>>> b
[5, 4, 3, 2, 1]
>>> id(a)
140349324204360
>>> id(b)
140349324192200

 

五、元组

元组属于不可变类型，序列类型，可哈希，同列表的区别只有元组不可变

1.tuple()不能用于创建元组，只能用于将其他类型转换为元组

>>> a=tuple(1,2,3)#无法使用类似list()方法创建空tuple

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple expected at most 1 arguments, got 3
>>> b=[1,2,3]
>>> c=tuple(b)
>>> c
(1, 2, 3)

2.tuple无法使用append()函数

3.tuple其他用法同list类型

六、字典

字典是另一种可变容器模型，且可存储任意类型对象。键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

两个重要的点需要记住：不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

append()函数也不能用

    # 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象
    # 不可变对象：调用对象自身的任意方法，也不会改变该对象自身的内容，这些方法会创建新的对象并返回。
    # 字符串、整数、tuple都是不可变对象，dict、set、list都是可变对象
    D[(1,2,3)] = 2                                    # tuple作为字典的key

1.创建&访问字典

>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> print(dict)
{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> dict2=dict(a=1,b=2,c=3)
>>> dict2
{'a': 1, 'b': 2, 'c': 3}
>>>dict3= dict([('name', 'tom'), ('age', 12)])  
{'age': 12, 'name': 'tom'}
>>>dict4=dict(zip(['name', 'age'], ['tom', 12]))   
{'age': 12, 'name': 'tom'}
#访问字典值
>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> print(dict['Alice'])
2341

2.修改字典

>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> dict['Alice']=12306
>>> dict
{'Alice': 12306, 'Beth': '9102', 'Cecil': '3258'}

3.删除字典

#清空字典元素
>>> dict={'Alice': 12306, 'Beth': '9102', 'Cecil': '3258'}
>>> dict.clear()
>>> dict
{}
#删除字典
>>> del dict
>>> dict
<class 'dict'>

3.1字典解析

>>> d={a:b for (a,b) in zip(['a','b','c'],[1,2,3])}
>>> d
{'a': 1, 'b': 2, 'c': 3}

3.2字典的特殊方法__missing__：当查找找不到key时，会执行该方法

#coding=utf-8
class Dict(dict):
     def __missing__(self, key):
         self[key] = []
         return self[key]
dct = Dict()
dct["foo"].append(1)    # 这有点类似于collections.defalutdict
a=dct["foo"]              # [1]
print(a)

 

4.字典函数

4.1clear() 函数用于删除字典内所有元素

clear()方法语法：dict.clear()
参数
NA。
返回值
该函数修改字典元素，没有任何返回值。字典是可变类型

>>> a=dict(a=1,b=2)
>>> a
{'a': 1, 'b': 2}
>>> a.clear()

4.2copy() 函数返回一个字典的浅复制。

>>> a=dict(a=1,b=2)
>>> id(a)
20573376
>>> b=a.copy()
>>> id(b)
20573280

4.3fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

fromkeys()方法语法：dict.fromkeys(seq[, value])
参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。
返回值
返回一个字典
>>> seq=('a','b','c')
>>> dict.fromkeys(seq)
{'a': None, 'b': None, 'c': None}
>>> dict.fromkeys(seq,10)
{'a': 10, 'b': 10, 'c': 10}

4.4get() 函数返回指定键的值，如果值不在字典中返回默认值。

get()方法语法：dict.get(key, default=None)
参数
key -- 字典中要查找的键。
default -- 如果指定键的值不存在时，返回该默认值值。
返回值
返回指定键的值，如果值不在字典中返回默认值 None。

>>> a=dict.fromkeys(('a','b','c'),10)
>>> a
{'a': 10, 'b': 10, 'c': 10}
>>> a.get('a')
10

4.5items() 方法以列表返回可遍历的(键, 值) 元组数组。

items()方法语法：dict.items()
参数
NA。
返回值
返回可遍历的(键, 值) 元组数组。
>>> a=dict.fromkeys(('a','b','c'),10)
>>> a.items()
dict_items([('a', 10), ('b', 10), ('c', 10)])
>>> b=a.items()
>>> type(b)
<class 'dict_items'>
>>> for i in b:
...     print(i)
...
('a', 10)
('b', 10)
('c', 10)

4.6keys()&values()方法返回一个迭代器，可以使用 list() 来转换为列表。

keys()方法语法：dict.keys()
参数
NA。
返回值
返回一个迭代器。
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys())             # 转换为列表
['Name', 'Age']
>>> 

>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict.values()
dict_values(['Runoob', 7])
>>> list(dict.values())
['Runoob', 7]

4.7update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里,相同值旧字典被新字典覆盖。

update() 方法语法：dict.update(dict2)
参数
dict2 -- 添加到指定字典dict里的字典。
返回值
该方法没有任何返回值。
>>> a={'a': 10, 'b': 10, 'c': 10}
>>> b={'e':1}
>>> c=a.update(b)
>>> print(c)
None
>>> print(a)
{'a': 10, 'b': 10, 'c': 10, 'e': 1}

4.8pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

pop()方法语法：pop(key[,default])
参数
key: 要删除的键值
default: 如果没有 key，返回 default 值
返回值
返回被删除的值。

>>> site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.pop('name')
>>> print(pop_obj)

4.9popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。如果字典已经为空，却调用了此方法，就报出KeyError异常。

popitem()方法语法：dict.popitem()
参数
无
返回值
返回一个被删除的键值对(key,value)形式。

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)   
print(site)
输出结果为：
('url', 'www.runoob.com')
{'name': '菜鸟教程', 'alexa': 10000}

4.10setdefault() 添加键值对，方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

setdefault()方法语法：dict.setdefault(key, default=None)
参数
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。
返回值
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

dict = {'Name': 'Runoob', 'Age': 7}

print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
print ("新字典为：", dict)
以上实例输出结果为：
Age 键的值为 : 7
Sex 键的值为 : None
新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}

七、集合

集合（set）是一个无序不重复元素的序列。分为可变集合、不可变集合(冻结集合)

    set是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
    set支持union(联合), intersection(交), difference(差)和symmetric difference(对称差集)等数学运算。
    set支持x in set, len(set), for x in set。
    set不记录元素位置或者插入点, 因此不支持indexing, slicing, 或其它类序列的操作

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

1.创建集合

#非空集合
>>> a={1,2,3,4}
>>> type(a)
<class 'set'>
>>> a=set(1,2,3,4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: set expected at most 1 arguments, got 4
>>> a=set([1,2,3,4])
>>> type(a)
<class 'set'>
>>> print(a)
{1, 2, 3, 4}
#空集合
>>> a={}
>>> b=set()
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'set'>

2.集合操作符

>>> a=set('dasdhshdkjdlas')
>>> b=set('daskldfhalkdfjier')
>>> a
{'j', 'k', 'a', 'd', 's', 'l', 'h'}
>>> a>b                            #a>b超集
False
>>> a<b                            #a<b子集
True
>>> a>=b a.issuperset(b)           #严格超集
False
>>> a<=b a.issubset(b)             #严格子集
True
>>> a|b  a.union(b)                #a|b,联合，等价‘or’返回a、b所有元素（不重复）
{'i', 'a', 'e', 'l', 'h', 'j', 'k', 'f', 'd', 's', 'r'}
>>> a&b  a.insersection(b)         #a%b交集，返回a存在且b存在的元素
{'k', 'j', 'a', 'd', 's', 'l', 'h'}
>>> a-b  a.difference(b)            #a-b,差集，返回a存在b不存在的元素
set()
>>> a^b  a.symmetric_difference(b) #a^b对称差分集,返回只在a和只在b的元素
{'i', 'e', 'f', 'r'}

3.列表推导式

类似列表推导式，同样集合支持集合推导式(Set comprehension):
实例
>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

4.集合函数

4.1add()添加元素

语法:set.add(obj)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

4.2update()更新集合

语法:set.update(obj)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  #可以以列表形式传入元素
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

4.3remove()删除元素

语法:set.remove(obj)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

4.4discard()删除元素

语法：set.discard(obj)
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

4.5pop()随机删除元素

#集合不可传入索引传入参数
>>> a=set('dasdhshdkjdlas')
>>> a.pop()
'j'
>>> a.pop(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)

4.6len()计算集合个数

#内建函数
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

4.7clear()清空集合

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

4.8copy()浅复制

>>> a=set([1,2,3,4])
>>> id(a)
140552174550272
>>> b=a.copy()
>>> id(b)
140552174750280

5.不可变集合(frozenset)

frozenset是不可变对象，即存在hash值，可作为字典的键值,frozenset对象没有add、remove等方法，但有union/intersection/difference等方法

set是可变对象，即不存在hash值，不能作为字典的键值。同样的还有list等(tuple是可以作为字典key的)

>>> a=set([1,2,3])
>>> b=set()
>>> b.add(a)                            # error: set是不可哈希类型,不可用add
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> b.add(frozenset(a))                 #ok，将set变为frozenset，可哈希
>>> print(b)
set([frozenset([1, 2, 3])]) 

八、布尔：Ture、False

>>> type(True)
<type 'bool'>
>>> isinstance(False,int)
True
>>> True==1
True
>>> True is 1
False

九、None

十、文件

0.标准读取方式

with open('c:\abc.txt',encoding='utf-8','r+') as f :#语句执行完后自动关闭文档不用close()
    count=0                #缩进
    for line in f:
        if count==9:
            count+=1
            continue
        print(line)    #读取1-10行
        count+=1
    

1.open()函数

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写

file object = open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

各个参数的细节如下：
    file object：创建一个文件对象
    file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
    access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
    buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
r         #读,指针在开头，不会创建
r+        #读写，指针在开头，不会创建
w         #写，指针在开头，不存在则创建
w+        #读写，指针在开头，不存在则创建
a         #追加，指针在结尾，不存在则创建
a+        #读+追加，指针在结尾，不存在则创建
rb,wb,ab,rb+,wb+,ab+    #二进制文件，读写模式同文本模式

实例：
file=open('/home/zelin/python_train.py',r+)
file=open('f.txt', encoding = 'latin-1')     # Python3.x Unicode文本文件
file=open('f.bin', 'rb')                     # Python3.x 二进制bytes文件

2.文件对象的属性:文件对象还有相应的属性：buffer closed encoding errors line_buffering name newlines等

file.closed	返回true如果文件已被关闭，否则返回false。注意与file.close()的区别
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

3.close函数，关闭文档

file=open('/home/zelin/log.log','r+')#打开
file.close()#关闭

4.read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10)
print "读取的字符串是 : ", str
# 关闭打开的文件
fo.close()

5.readline()读一行，返回字符串

>>> f=open('/home/zelin/python_train.py','r+')
>>> f.readline()
'#coding=utf-8\n'

6.readlines()把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长。

>>> f.readlines()
['class Dict(dict):\n', '     def __missing__(self, key):\n', '         self[key] = []\n', '         return self[key]\n', 'dct = Dict()\n', 'dct["foo"].append(1)    # 这有点类似于collections.defalutdict\n', 'a=dct["foo"]              # [1]\n', 'print(a)\n']

7.write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符('\n')：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "w")
fo.write( "www.runoob.com!\nVery good site!\n")
 
# 关闭打开的文件
fo.close()

8.writelines(seq)把seq的内容全部写到文件中(多行一次性写入，同样不会自动添加\n)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 打开文件
fo = open("test.txt", "w")
print "文件名为: ", fo.name
seq = ["菜鸟教程 1\n", "菜鸟教程 2"]
fo.writelines( seq )

# 关闭文件
fo.close()

9.readable()是否可读

10.writeable()是否可写

11.seekable()是否可以seek

12.tell() 返回文件操作标记的当前位置，以文件的开头为原点

13.seek(offset[,whence])将文件打开操作标记移到offset的位置。whence为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。

f.tell()
f.seek(30)
注意：seek不能指针往前移动后再写入，根据写入内存机制，这样会覆盖原有内存上写入的内容(即原有内容)进而破坏整个文档

14.truncate([size]) 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。

15.next() 返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

for line in open('data'): 
        print(line)                         # 使用for语句，比较适用于打开比较大的文件

十一、时间格式

1.一些术语和约定的解释：

    1.1.时间戳(timestamp)的方式：浮点数，通常来说，时间戳表示的是从1970年1月１日开始按秒计算的偏移量(time.gmtime(0))此模块中的函数无法处理1970纪元年以前的时间或太遥远的未来(处理极限取决于C函数库，对于32位系统而言，是2038年)
    1.2.UTC(Coordinated Universal Time,世界协调时)也叫格林威治天文时间，是世界标准时间．在我国为UTC+8
    1.3.DST(Daylight Saving Time)即夏令时
    1.4.一些实时函数的计算精度可能不同

    1.5时间类型：

字符串('2018-11-09')，

时间戳(12123.22132)，

时间元组(time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1))

 

2.time.time()获取当前时间戳，单位为秒

import time,datetime
>>> time.time()
1538102451.9240968

3.time.sleep()等待时间，延迟线程的运行，单位是s

#coding=utf-8
import time
st=time.time()#第一个时间戳
time.sleep(2)
et=time.time()#第二个时间戳
t=et-st#计算时间差
print(t)
============================================
#返回值
2.0004122257232666

4.time.strftime(format,t)将时间元组或者struct_time格式转换为时间格式,format为时间格式，t为转换前的格式，不指定t默认为time.localtime()

   time.strptime(ti,format)将时间格式字符串转换为时间元组，format表示时间格式，ti表示时间，是time.strftime的反函数

import time datetime
#默认为当前的localtime，所以t不赋值也是可以的
>>> time.strftime('%Y-%m-%d %H:%M:S')
'2018-09-28 10:48:S'
>>> time.strftime('%Y-%m-%d %H:%M:%S')
'2018-09-28 10:48:33'
>>> time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
'2018-09-28 10:49:05'
>>> time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
'2018-09-28 10:49:12'
>>> time.strptime("30 Nov 00", "%d %b %y")   
time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

format格式如下：
    %a      本地(local)简化星期名称
    %A      本地完整星期名称
    %b      本地简化月份名称
    %B      本地完整月份名称
    %c      本地相应的日期和时间表示
    %d      一个月中的第几天(01-31)
    %H      一天中的第几个小时(24小时制，00-23)
    %l      一天中的第几个小时(12小时制，01-12)
    %j      一年中的第几天(01-366)
    %m      月份(01-12)
    %M      分钟数(00-59)
    %p      本地am或者pm的相应符
    %S      秒(01-61)
    %U      一年中的星期数(00-53,星期天是一个星期的开始,第一个星期天之前的所有天数都放在第０周)
    %w      一个星期中的第几天(0-6,0是星期天)
    %W      和%U基本相同，不同的是%W以星期一为一个星期的开始
    %x      本地相应日期
    %X      本地相应时间
    %y      去掉世纪的年份(00-99)
    %Y      完整的年份       
    %z      用+HHMM或者-HHMM表示距离格林威治的时区偏移(H代表十进制的小时数，M代表十进制的分钟数)
    %Z      时区的名字(如果不存在为空字符)
    %%      %号本身
            %p只有与%I配合使用才有效果
            当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U和%W才会被计算

5.time.localtime(secs)接受时间戳，返回当地时间元组，参数secs默认为当下时间，即time.time();

   time.gmtime(secs)接收时间戳，返回格林威治天文时间元组，与time.localtime()表示的时间不同

   time.mktime(t)接收时间元组，返回本地时间戳，是time.localtime()的反函数

import time
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=9, tm_mday=28, tm_hour=11, tm_min=6, tm_sec=34, tm_wday=4, tm_yday=271, tm_isdst=0)
>>> time.localtime(time.time())
time.struct_time(tm_year=2018, tm_mon=9, tm_mday=28, tm_hour=11, tm_min=10, tm_sec=16, tm_wday=4, tm_yday=271, tm_isdst=0)
>>> time.gmtime(time.time())
time.struct_time(tm_year=2018, tm_mon=9, tm_mday=28, tm_hour=3, tm_min=23, tm_sec=35, tm_wday=4, tm_yday=271, tm_isdst=0)

6.time.ctime()获取完整表达当前时间的24个字符串，效果同time.asctime()

import time
>>> time.ctime()
'Fri Sep 28 11:19:36 2018'#星期 月份 日期 时间 年份
>>> time.asctime()
'Fri Sep 28 11:21:03 2018'

7.time.struct_time 时间元组

import time
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=9, tm_mday=28, tm_hour=11, tm_min=42, tm_sec=32, tm_wday=4, tm_yday=271, tm_isdst=0)






时间元祖(time.struct_time)

gmtime(),localtime()和strptime()以时间元祖(struct_time)的形式返回

索引值(index) 	属性(Attribute) 	值(Values)
0 	tm_year(年) 	(例如:2015)
1 	tm_mon(月) 	1-12
2 	tm_mday(日) 	1-31
3 	tm_hour(时) 	0-23
4 	tm_min(分) 	0-59
5 	tm_sec(秒) 	0-61(60代表闰秒,61是基于历史原因保留)
6 	tm_wday(星期几) 	0-6(0表示星期一)
7 	tm_yday(一年中的第几天) 	1-366
8 	tm_isdst(是否为夏令时) 	0,1,-1(-1代表夏令时)

8.datetime模块

datetime模块的对象有如下：

• datetime
• date
• time
• tzinfo
• timedelta

还包含以下两个常量：

• datetime.MINYEAR （它返回的是1）
• datetime.MAXYEAR（它返回的是9999）

datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])
year, month 和 day 参数是必须的，其他参数可选， 参数tzinfo表示可选的时区信息，一般我们也用不到。

参数值的范围如下：

• MINYEAR <= year <= MAXYEAR
• 1 <= month <= 12
• 1 <= day <= number of days in the given month and year
• 0 <= hour < 24
• 0 <= minute < 60
• 0 <= second < 60
• 0 <= microsecond < 1000000

from datetime import datetime as dt
t=dt(2017,6,1,hour=13,minute=17,second=30)
print(type(t))
print(t)
#返回值
<class 'datetime.datetime'>
2017-06-01 13:17:30
=========================================================
#如果我们只传参数year, month, day，那么时间会默认变成00：00：00
from datetime import datetime as dt
t=dt(2017,6,1)
print(t)
#返回值：2017-06-01 00:00:00

datetime.datetime.today()和datetime.datetime.now(),都是返回当前的时间

>>> datetime.datetime.today()
datetime.datetime(2018, 9, 28, 14, 48, 26, 187434)
>>> datetime.datetime.now()
datetime.datetime(2018, 9, 28, 14, 48, 31, 900227)

datetime.datetime对象还有两个属性：min和max

from datetime import datetime as dt
min_time=dt.min
max_time=dt.max
print(min_time)
print(max_time)

输出：
0001-01-01 00:00:00
9999-12-31 23:59:59.999999