袁老师Py西游攻关之基础数据类型

2019年12月07日 阅读数:85
这篇文章主要向大家介绍袁老师Py西游攻关之基础数据类型,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

Py西游攻关之基础数据类型

数据类型

计算机顾名思义就是能够作数学计算的机器,所以,计算机程序理所固然地能够处理各类数值。可是,计算机能处理的远不止数值,还能够处理文本、图形、音频、视频、网页等各类各样的数据,不一样的数据,须要定义不一样的数据类型。在Python中,可以直接处理的数据类型有如下几种html

一 Number(数字)

1.1 数字类型的建立

1
2
3
4
5
6
a = 10
b = a
b = 666
 
print (a) #10
print (b) #666

 

注意这里与C的不一样:python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
void main(void)
{
 
     int  =  1 ;
     int  =  a;
     printf ( "a:adr:%p,val:%d,b:adr:%p,val:%d\n" ,&a,a,&b,b);
     =  3 ;
     printf ( "a:adr:%p,val:%d,b:adr:%p,val:%d\n" ,&a,a,&b,b);
 
}
 
/ / 打印结果:
topeet@ubuntu:~$ gcc test.c
topeet@ubuntu:~$ . / a.out
a:adr: 0x7fff343a069c ,val: 1
b:adr: 0x7fff343a0698 ,val: 1
a:adr: 0x7fff343a069c ,val: 3
b:adr: 0x7fff343a0698 ,val: 1

1.2 Number 类型转换

1
2
3
4
5
6
var1 = 3.14
var2 = 5
var3 = int (var1)
var4 = float (var2)
 
print (var3,var4)
  PY内置数学函数

二 字符串类型(string)

字符串是以单引号'或双引号"括起来的任意文本,好比'abc'"123"等等。编程

请注意,''""自己只是一种表示方式,不是字符串的一部分,所以,字符串'abc'只有abc这3个字符。若是'自己也是一个字符,那就能够用""括起来,好比"I'm OK"包含的字符是I'm,空格,OK这6个字符。ubuntu

2.1 建立字符串:数据结构

1
2
var1  =  'Hello World!'
var2  =  "Python RAlvin"

对应操做:app

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1   * 重复输出字符串
print ( 'hello' * 2 )
 
# 2 [] ,[:] 经过索引获取字符串中字符,这里和列表的切片操做是相同的,具体内容见列表
print ( 'helloworld' [ 2 :])
 
# 3 in  成员运算符 - 若是字符串中包含给定的字符返回 True
print ( 'el'  in  'hello' )
 
# 4 %   格式字符串
print ( 'alex is a good teacher' )
print ( '%s is a good teacher' % 'alex' )
 
 
# 5 +   字符串拼接
a = '123'
b = 'abc'
c = '789'
d1 = a + b + c
print (d1)
# +效率低,该用join
d2 = ''.join([a,b,c])
print (d2)

python的内置方法编程语言

  View Code

三 字节类型(bytes)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# a=bytes('hello','utf8')
# a=bytes('中国','utf8')
 
 
a = bytes( '中国' , 'utf8' )
b = bytes( 'hello' , 'gbk' )
#
print (a)         #b'\xe4\xb8\xad\xe5\x9b\xbd'
print ( ord ( 'h' ))  #其十进制 unicode 值为: 104
print ( ord ( '中' )) #其十进制 unicode 值为:20013
 
#  h   e  l   l   o
# 104 101 108 108 111   编码后结果:与ASCII表对应
 
 
#     中                国
#   \xd6\xd0         \xb9\xfa       gbk编码后的字节结果
#\xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8编码后的字节结果
# 228 184 173      229 155  189        a[:]切片取
 
 
c = a.decode( 'utf8' )
d = b.decode( 'gbk' )
#b=a.decode('gbk') :很明显报错
 
print (c)  #中国
print (d)  #hello 

注意:对于 ASCII 字符串,由于不管哪一种编码对应的结果都是同样的,因此能够直接使用 b'xxxx' 赋值建立 bytes 实例,但对于非 ASCII 编码的字符则不能经过这种方式建立 bytes 实例,须要指明编码方式。函数

1
2
3
4
5
6
b1 = b '123'
print ( type (b1))
# b2=b'中国' #报错
# 因此得这样:
b2 = bytes( '中国' , 'utf8' )
print (b2) #b'\xe4\xb8\xad\xe5\x9b\xbd'

四 布尔值

一个布尔值只有TrueFalse两种值,要么是True,要么是False,在Python中,能够直接用TrueFalse表示布尔值(请注意大小写)post

1
2
3
4
print ( True )
print ( 4 > 2 )
print ( bool ([ 3 , 4 ]))
print ( True + 1 )

与或非操做:测试

1
2
3
4
bool ( 1  and  0 )
bool ( 1  and  1 )
bool ( 1  or  0 )
bool ( not  0 )

布尔值常常用在条件判断中:

1
2
3
4
5
age = 18
if  age> 18 : #bool(age>18)
     print ( 'old' )
else :
     print ( 'young' )

  

五 List(列表)

      OK,如今咱们知道了字符串和整型两个数据类型了,那需求来了,我想把某个班全部的名字存起来,怎么办?

有同窗说,不是学变量存储了吗,我就用变量存储呗,呵呵,不嫌累吗,同窗,如班里有一百我的,你就得建立一百个变量啊,消耗大,效率低。

又有同窗说,我用个大字符串不能够吗,没问题,你的确存起来了,可是,你对这个数据的操做(增删改查)将变得很是艰难,不是吗,我想知道张三的位置,你怎么办?

 

在这种需求下,编程语言有了一个重要的数据类型----列表(list)

 

什么是列表:

列表(list)是Python以及其余语言中最经常使用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的(mutable)——能够改变列表的内容。

 

对应操做:

1 查([])

1
2
3
4
5
6
7
8
9
10
names_class2 = [ '张三' , '李四' , '王五' , '赵六' ]
 
# print(names_class2[2])
# print(names_class2[0:3])
# print(names_class2[0:7])
# print(names_class2[-1])
# print(names_class2[2:3])
# print(names_class2[0:3:1])
# print(names_class2[3:0:-1])
# print(names_class2[:]) 

2 增(append,insert)

insert 方法用于将对象插入到列表中,而append方法则用于在列表末尾追加新的对象

1
2
3
names_class2.append( 'alex' )
names_class2.insert( 2 , 'alvin' )
print (names_class2)

3 改(从新赋值)

1
2
3
4
5
names_class2 = [ '张三' , '李四' , '王五' , '赵六' ]
 
names_class2[ 3 ] = '赵七'
names_class2[ 0 : 2 ] = [ 'wusir' , 'alvin' ]
print (names_class2)

4 删(remove,del,pop)

1
2
3
4
names_class2.remove( 'alex' )
del  names_class2[ 0 ]
del  names_class2
names_class2.pop() #注意,pop是有一个返回值的 

5 其余操做

5.1  count

       count 方法统计某个元素在列表中出现的次数:

1
2
3
4
5
6
7
>>> [ 'to' 'be' 'or' 'not' 'to' 'be' ].count( 'to'
2 
>>> x  =  [[ 1 , 2 ],  1 1 , [ 2 1 , [ 1 2 ]]] 
>>> x.count( 1
2 
>>> x.count([ 1 , 2 ]) 
1

5.2 extend

         extend 方法能够在列表的末尾一次性追加另外一个序列中的多个值。

1
2
3
4
5
>>> a  =  [ 1 2 3
>>> b  =  [ 4 5 6
>>> a.extend(b) 
>>> a 
[ 1 2 3 4 5 6

  extend 方法修改了被扩展的列表,而原始的链接操做(+)则否则,它会返回一个全新的列表。

1
2
3
4
5
6
7
8
9
10
>>> a  =  [ 1 2 3
>>> b  =  [ 4 5 6
>>> a.extend(b) 
>>> a 
[ 1 2 3 4 5 6
>>> 
>>> a  + 
[ 1 2 3 4 5 6 4 5 6
>>> a 
[ 1 2 3 4 5 6

5.3  index

       index 方法用于从列表中找出某个值第一个匹配项的索引位置: 

1
names_class2.index( '李四' )

5.4  reverse

       reverse 方法将列表中的元素反向存放。

1
2
names_class2.reverse()
print (names_class2)

5.5  sort

       sort 方法用于在原位置对列表进行排序。

1
2
=  [ 4 6 2 1 7 9 ]
x.sort() #x.sort(reverse=True)

5.6  深浅拷贝

如今,你们先不要理会什么是深浅拷贝,听我说,对于一个列表,我想复制一份怎么办呢?

确定会有同窗说,从新赋值呗:

1
2
names_class1 = [ '张三' , '李四' , '王五' , '赵六' ]
names_class1_copy = [ '张三' , '李四' , '王五' , '赵六' ]

这是两块独立的内存空间

这也没问题,仍是那句话,若是列表内容作够大,你真的能够要每个元素都从新写一遍吗?固然不啦,因此列表里为咱们内置了copy方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
names_class1 = [ '张三' , '李四' , '王五' , '赵六' ,[ 1 , 2 , 3 ]]
names_class1_copy = names_class1.copy()
 
names_class1[ 0 ] = 'zhangsan'
print (names_class1)
print (names_class1_copy)
 
############
names_class1[ 4 ][ 2 ] = 5
print (names_class1)
print (names_class1_copy)
 
#问题来了,为何names_class1_copy,从这一点咱们能够判定,这两个变量并非彻底独立的,那他们的关系是什么呢?为何有的改变,有的不改变呢?

这里就涉及到咱们要讲的深浅拷贝了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#不可变数据类型:数字,字符串,元组         可变类型:列表,字典
 
# l=[2,2,3]
# print(id(l))
# l[0]=5
# print(id(l))   # 当你对可变类型进行修改时,好比这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
#                # this is the most important
#
# s='alex'
# print(id(s))   #像字符串,列表,数字这些不可变数据类型,,是不能修改的,好比我想要一个'Alex'的字符串,只能从新建立一个'Alex'的对象,而后让指针只想这个新对象
#
# s[0]='e'       #报错
# print(id(s))
 
#重点:浅拷贝
a = [[ 1 , 2 ], 3 , 4 ]
b = a[:] #b=a.copy()
 
print (a,b)
print ( id (a), id (b))
print ( '*************' )
print ( 'a[0]:' , id (a[ 0 ]), 'b[0]:' , id (b[ 0 ]))
print ( 'a[0][0]:' , id (a[ 0 ][ 0 ]), 'b[0][0]:' , id (b[ 0 ][ 0 ]))
print ( 'a[0][1]:' , id (a[ 0 ][ 1 ]), 'b[0][1]:' , id (b[ 0 ][ 1 ]))
print ( 'a[1]:' , id (a[ 1 ]), 'b[1]:' , id (b[ 1 ]))
print ( 'a[2]:' , id (a[ 2 ]), 'b[2]:' , id (b[ 2 ]))
 
 
print ( '___________________________________________' )
b[ 0 ][ 0 ] = 8
 
print (a,b)
print ( id (a), id (b))
print ( '*************' )
print ( 'a[0]:' , id (a[ 0 ]), 'b[0]:' , id (b[ 0 ]))
print ( 'a[0][0]:' , id (a[ 0 ][ 0 ]), 'b[0][0]:' , id (b[ 0 ][ 0 ]))
print ( 'a[0][1]:' , id (a[ 0 ][ 1 ]), 'b[0][1]:' , id (b[ 0 ][ 1 ]))
print ( 'a[1]:' , id (a[ 1 ]), 'b[1]:' , id (b[ 1 ]))
print ( 'a[2]:' , id (a[ 2 ]), 'b[2]:' , id (b[ 2 ]))<br><br><br> #outcome
# [[1, 2], 3, 4] [[1, 2], 3, 4]
# 4331943624 4331943752
# *************
# a[0]: 4331611144 b[0]: 4331611144
# a[0][0]: 4297375104 b[0][0]: 4297375104
# a[0][1]: 4297375136 b[0][1]: 4297375136
# a[1]: 4297375168 b[1]: 4297375168
# a[2]: 4297375200 b[2]: 4297375200
# ___________________________________________
# [[8, 2], 3, 4] [[8, 2], 3, 4]
# 4331943624 4331943752
# *************
# a[0]: 4331611144 b[0]: 4331611144
# a[0][0]: 4297375328 b[0][0]: 4297375328
# a[0][1]: 4297375136 b[0][1]: 4297375136
# a[1]: 4297375168 b[1]: 4297375168
# a[2]: 4297375200 b[2]: 4297375200

那么怎么解释这样的一个结果呢?

  

 再不懂,俺就没办法啦...

列表补充:

b,*c=[1,2,3,4,5]

六 tuple(元组

元组被称为只读列表,即数据能够被查询,但不能被修改,因此,列表的切片操做一样适用于元组。

元组写在小括号(())里,元素之间用逗号隔开。

虽然tuple的元素不可改变,但它能够包含可变的对象,好比list列表。

构造包含 0 个或 1 个元素的元组比较特殊,因此有一些额外的语法规则:

1
2
tup1  =  ()     # 空元组
tup2  =  ( 20 ,)  # 一个元素,须要在元素后添加逗号
做用:

1 对于一些数据咱们不想被修改,可使用元组;

2 另外,元组的意义还在于,元组能够在映射(和集合的成员)中看成键使用——而列表则不行;元组做为不少内建函数和方法的返回值存在。 

字典

  购物车实例

七 Dictionary(字典)

字典是python中惟一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,因此字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。二者之间的区别在于:字典当中的元素是经过键来存取的,而不是经过偏移存取。

建立字典:     

1
2
3
4
dic1 = { 'name' : 'alex' , 'age' : 36 , 'sex' : 'male' }
dic2 = dict ((( 'name' , 'alex' ),))
print (dic1)
print (dic2)

对应操做:

1 增

1
2
3
4
5
6
7
8
9
10
dic3 = {}
 
dic3[ 'name' ] = 'alex'
dic3[ 'age' ] = 18
print (dic3) #{'name': 'alex', 'age': 18}
 
a = dic3.setdefault( 'name' , 'yuan' )
b = dic3.setdefault( 'ages' , 22 )
print (a,b)
print (dic3)

2 查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dic3 = { 'name' 'alex' 'age' 18 }
 
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
 
print (dic3.items())
print (dic3.keys())
print (dic3.values())
 
print ( 'name'  in  dic3) # py2:  dic3.has_key('name')
print ( list (dic3.values()))

3 改

1
2
3
4
5
6
dic3 = { 'name' 'alex' 'age' 18 }
 
dic3[ 'name' ] = 'alvin'
dic4 = { 'sex' : 'male' , 'hobby' : 'girl' , 'age' : 36 }
dic3.update(dic4)
print (dic3)

4 删

1
2
3
4
5