x=20		#八进制为24
y=345.6
print(oct(x)) 	#打印结果是0o24
print(int(y)) 		#打印结果是345
print(float(x)) 	#打印结果是20.0
print(chr(65)) 	# A的ASCII为65，打印结果是A
print(ord('a')) 	# B的ASCII为97，打印结果是97

2.2 ?常量和变量

?2.2.1 ?变量 ? ? ?

变量在程序中就是用一个变量名表示，变量名必须是大小写英文、数字和下划线_的组合，且不能用数字开头，比如： ? ? ? 在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：?

  a = 123             # a是整数
  a = 'ABC'           # a变为字符串
  a=True              # a变为一个布尔值True

?? ? ? 这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言（例如C语言）。

变量类型运行示例：

?2.2.2 ?常量

所谓常量，就是不能变的变量。 ?

比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量： ? ? ? ? ? ? ? ? ? ? ? ? ?PI = 3.14159265359 ? ?

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，实际上是可以改变变量PI的值。 ? ? ?

（Python中的常量与许多其他程序设计语言的中常量有差别）

2.3 ?运算符与表达式

?Python语言支持的运算符有以下几种类型：

算术运算符?
比较(即关系)运算符
赋值运算符
?逻辑运算符
位运算符
成员操作符
标识操作符

?1．算术运算符 ?

算术运算符实现数学运算，Python语言算术运算符如表2-5所示。 ?

?假设其中变量a=10和变量b=20。?

?关系运算符用于两个值进行比较，运算结果为True（真）或False（假）。Python中的关系运算符如表2-6所示。假设其中变量a=10和变量b=20。

?3．逻辑运算符

Python中提供了三种逻辑运算符： ? ? ? ?

and（逻辑与，二元运算符） ? ? ? ?

or ?（逻辑或，二元运算符） ? ? ? ?

not （逻辑非，一元运算符）

?4．赋值运算符

赋值运算符“=”的一般格式为： ? ? ? ? ? ? ? ? ? ? ? ? ? ?

变量=表达式 ? ? ? 它表示将其右侧的表达式求出结果，赋给其左侧的变量。例如：

>>>i=3*(4+5)	# i的值变为27
>>> i=True+5    # i的值变为6

?5．位运算符

位（bit）是计算机中表示信息的最小单位。 ? ? ? ? ? ?

位运算符作用于位和位操作。

Python中位运算符如下：

按位与（&）、按位或（|）、按位异或（＾）、按位求反（~）、左移（<<）、右移（>>）。

位运算符是对其操作数按其二进制形式逐位进行运算。
?

a = ?    0011 1100

b = ?? ? 0000 1101

a&b =?? ?0000 1100

a|b = ?? 0011 1101

a^b =?? ?0011 0001 ?

~a =??   1100 0011

?6．Python成员运算

Python成员运算符判断序列中是否有某个成员。成员运算符如表2-9所示。

?7. ?Python标识运算符

标识符比较两个对象的内存位置。

例1：
a=20
b=20
if(a is b):
     print(“a和b相等”)
Else:
     print(“a和b不等”)

例2：
a=20
b=20
if(id(a) is not id(b)):
     print(“a和b不等”)
Else:
     print(“a和b相等”)

2.3.2 表达式

表达式是一个或多个运算的组合。Python语言的表达式与其他语言的表达式没有显著的区别。每个符合Python语言规则的表达式的计算都是一个确定的值。对于常量、变量的运算和对于函数的调用都可以构成表达式。在后续章节中介绍的序列、函数、对象都可以成为表达式一部分。

2.4 ?序列数据结构

????????数据结构是计算机存储、组织数据的方式。序列是Python中最基本的数据结构。 ? ?

????????序列中的每个元素都分配一个数字即它的位置或索引，第一个索引是0，第二个索引是1，依此类推。序列都可以进行的操作包括索引、截取（切片）、加、乘、成员检查。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 ? ? ?

Python内置序列类型最常见的是列表、元组、字符串 ? ? 另外，Python提供了字典和集合这样的数据结构，它们属于无顺序的数据集合体，不能通过位置索引号来访问数据元素。

2.4.1 ?列表

列表（list）是最常用的Python数据类型，列表的数据项不需要具有相同的类型。列表类似其他语言的数组，但功能比数组强大的多。创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。实例如下：

list1 = ['中国', '美国', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
列表索引从0开始。
列表可以进行截取（切片）、组合等。

1．访问列表中的值
list1 = ['中国', '美国', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print ("list1[0]: ", list1[0] )
print ("list2[1:5]: ", list2[1:5] )

2．更新列表

可以对列表的数据项进行修改或更新，实例如下：

list = ['中国', 'chemistry', 1997, 2000];
print ( "Value available at index 2 : ")
print (list[2] )
list[2] = 2001
print ( "New value available at index 2 : ")
print (list[2] )

3．删除列表元素

方法一： ? ? ?使用 del 语句来删除列表的的元素。

方法二： ? ? ?使用 remove()方法来删除列表的元素。

方法三： ? ? 使用pop()方法方法来删除列表的指定位置的元素，无参数时删除最后一个元素。?

?注意：如利用remove 删除，列表中有几个相同值的元素，则删除第一个与remove的值相等的列表元素，后面的值不受影响。

?2.4.1 ?列表

4．添加列表元素可以使用 append()方法在列表末尾添加元素，如下实例：

list1 = ['中国', '美国', 1997, 2000]
list1.append(2003)
print (list1)
以上实例输出结果：
['中国', '美国', 1997, 2000, 2003]

添加列表元素示例：可使用append()方法在列表末尾添加元素。或使用insert(index,obj)的方法在列表中任意索引位置插入数据。

5．定义多维列表

可将多维列表视为列表的嵌套，即多维列表的元素值也是一个列表，只是维度比父列表小一。

 例如：定义1个二维列表。
 list2 = [["CPU", "内存"], ["硬盘","声卡"]]

二维列表比一维列表多一个索引，可如下获取元素： ? ? ? ? ? ? ? ? ? ? ? ?

列表名[索引1][索引2]

例：定义3行6列的二维列表，打印出元素值。

rows=3
cols=6
matrix = [[0 for col in range(cols)] for row in range(rows)]   
                                                                  #列表生成式
for i in range(rows):  
    for j in range(cols):
        matrix[i][j]=i*3+j
        print (matrix[i][j],end=",")  
    print ('\n')

Python列表的操作符

len([1,2,3])               #长度          	   3

[1,2,3]+[4,5,6]            #组合               [1,2,3,4,5,6] 

[3]*4                      #重复         	   [3, 3, 3, 3]

‘a’in [‘a’,1,2]            #元素是否在列表中    True

for x in [‘a’,‘中国’,1]:print(x,end=‘,’)   #迭代a,中国,1,

Python列表内置函数和方法?

?2.4.2 ?元组

?Python的元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组使用小括号()，列表使用方括号[]。元组中的元素类型也可以不相同。

1．创建元组
tup1 = ('中国', '美国', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
2．访问元组
tup1 = ('中国', '美国', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])          # 输出元组的第一个元素
print ("tup2[1:5]: ", tup2[1:5])   # 切片，输出从第二个元素开始到第五个元素
print (tup2[2:])

?3．元组连接 ? ? ? ?

元组中的元素值是不允许修改的，但可以对元组进行连接组合，实例如下：

tup1 = (12, 34,56)
tup2 = (78, 90)
#tup1[0] = 100          #修改元组元素操作是非法的
tup3 = tup1 + tup2	#连接元组，创建一个新的元组
print (tup3)
以上实例输出结果：(12, 34,56, 78, 90)

?4．删除元组 ? ? ? ?

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组。

元组与列表转换

可以使用下面方法将元组转换为列表：
    列表对象=list(元组对象)
tup=(1, 2, 3, 4, 5) 
list1= list(tup) 			    #元组转为列表
print (list1) 					#返回[1, 2, 3, 4, 5]
可以使用下面方法将列表转换为元组：
    元组对象= tuple (列表对象)
nums=[1, 3, 5, 7, 8, 13, 20]
print (tuple(nums))             #列表转为元组，返回(1, 3, 5, 7, 8, 13, 20)

2.4.3 ?字典

Python字典（dict）是一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等。字典也被称作关联数组或哈希表。

1．创建字典


键值对key-value
一个简单的字典实例：
dict = {'zhangsan' : 91 , 'wangwu' : 80}
也可如此创建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

?2．访问字典里的值 ? ? ? ? ? ?

访问字典里的值时把相应的键放入方括号里，如下实例：

dict = {'Name': '王海', 'Age': 17, 'Class': '计算机一班'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

3．修改字典

dict = {'Name': '王海', 'Age': 17, 'Class': '计算机一班'}
dict['Age'] = 18                 # 更新键/值对（update existing entry）
dict['School'] = "学院"  # 增加新的键/值对（add new entry）
print ("dict['Age']: ", dict['Age'] )
print ( "dict['School']: ", dict['School']

?字典与列表的比较：

列表保持元素的相对关系，即序列关系；但字典是完全无序的，也称为非序列。

如果向保持一个集合中元素的顺序，需要使用列表，而不是字典。字典从Python3.6版优化后，字典的输出顺序与创建之初的输出顺序相同，但仍然不能使用位置下标索引访问字典；而列表要用索引访问。

2.4.4 ?集合

集合（set）是一个无序不重复元素的序列。

集合基本功能是进行成员关系测试和删除重复元素。
1．创建集合

# set可以进行集合运算
a = set('abcd')        #a= {'a', 'b', 'c', 'd' }
b = set('cdef')
print(a)
print("a和b的差集：", a - b)    # a和b的差集{'a', 'b' }
print("a和b的并集：", a | b)    # a和b的并集 {'a', 'b', 'c', 'd' , 'e' }
print("a和b的交集：", a & b)    # a和b的交集{'c', 'd' }
print("a和b中不同时存在的元素：", a ^ b)    
                               # a和b中不同时存在的元素{'e', 'a', 'b', 'f'}

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

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉

集合运算

可以使用“-”、“|”、“&”“^”运算符进行集合的差集、并集、交集、元素不同时存在等相关运算。

# set可以进行集合运算
a = set('abcd')        #a= {'a', 'b', 'c', 'd' }
b = set('cdef')
print(a)
print("a和b的差集：", a - b)     # a和b的差集{'a', 'b' }
print("a和b的并集：", a | b)     # a和b的并集 {'a', 'b', 'c', 'd' , 'e' }
print("a和b的交集：", a & b)    # a和b的交集{'c', 'd' }
print("a和b中不同时存在的元素：", a ^ b)    
                                     # a和b中不同时存在的元素{'e', 'a', 'b', 'f'}