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>