1.Python对象类型及其运算

1.1Python对象的相关术语

Python程序中保存的所有数据都是围绕对象这个概念展开的
 -->程序中存储的所有数据都是对象
 -->每个对象都有一个身份、一个类型和一个值
    例如，school="MaGe Linux"会以"MaGe Linux"创建一个字符串对象，其身份是指向它在内存中所处的位置的指针(其在内存中的地址)
    而school就是引用这个具体位置的名称
 -->对象的类型也称对象的类别，用于描述对象的内部表示及它支持的方法和操作
 -->创建特定类型的对象时，有时也将该对象称为该类型的实例
 -->实例被创建后，其身份和类型就不可改变
    1.如果对象值是可修改的，则称为可变对象
    2.如果对象值是不可修改的，则称为不可变对象
 -->如果某个对象包含对其它对象的引用，则将其称为容器；
 -->大多数对象都拥有大量特有的数据属性和方法
    1.属性：与对象相关的值
    2.方法：被调用时将在对象上执行某些操作的函数
    3.使用点(.)运算符可以访问属性和方法

In [1]: name = "Jerry"
In [2]: id(name)    ##id所获取到的这个值就叫对象的身份，内存中的地址
Out[2]: 14158560
In [3]: type(name)  ##name类型
Out[3]: str

1.2对象的身份与类型

Python内置函数id()可返回一个对象的身份，即该对象在内存中的位置
 -->is运算符用于比较两个对象的身份
 -->type()用于返回一个对象的类型
 -->对象类型本身也是一个对象，称为对象的类
    >>该对象的定义是唯一的，且对于某类型的所有实例都是相同的
    >>所有类型对象都是一个指定的名称，可用于执行类型检查，如list、dict
[root@linux-node1 ~]# vim b.py   ##比较对象的三种方法
#!/usr/bin/python2
#
if a is b:
    statements
if a == b:
    statements
if type(a) is type(b):
    statements
两个对象的比较：
 1.值比较：对象中的数据是否相同
 2.身份比较：两个变量名引用的是否为同一对象
 3.类型比较：两个对象的类型是否相同

1.3Python核心数据类型

数字：int，long，flocat，complex，bool（整型，长整型，浮点型，复数，布尔型）
字符：str，unicode
列表：list
字典：dict
元组：tuple
文件：file
其他类型：集合（set），frozenset，类类型，空（None）

其他文件类工具：管道（pipes），先进先出管道（fifos），sockets

1.4类型转换常用的内置函数

 str（），repr（）或format()：用于实现非字符串转成字符串
 at（）：将非字符型数据转换为字符
 str：做对象序列化的结果，强制转换
 repr：做精确转换，不转换元对象
 format：
 int（）：转换成整数
 float（）：转换成浮点型

 list（s）：将字串s转换成列表
 tuple（s）：将字串s转换成元组
 set(s)：将字串s转换为集合
 frozenset（s）：将字串s转换为不可变集合
 dict（d）：根据指定的键值对创建字典，其中d必须是（key，value）的元组序列

 chr（x）：将整数转换为字符
 ord（x）:将字符转换为整数值
 hex(x)：将整数转换成16进制字符
 bin（x）：将整数转换成2进制字符
 oct（x）：将整数转换成8进制字符

1.5数字类型

python的数字字面量：布尔型，整数，浮点型，负数
 True：1
 False：0
 数字类型为不可变类型

math模块可以实现算术的高级运算

1.6序列类型

序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组

字符串是字符的

列表和元组是任意Python对象的序列

字符和元组属于不可变序列，而列表则支持插入、删除和替换元素

所有序列都支持迭代

序列类型：
 字符类型
 字符串字面量：把文本放入单引号、双引号或三引号中：前后要一致
 如果要使用unicode编码，则在字符之前使用字符u进行标识，如u“mageedu”

 文档字符串：模块、类或函数的第一条语句是一个字符的话，该字符串就成为文档字符串，可以使用__doc__来引用
In [11]: def printName():
 ....: "test function"
 ....: print "hello world"
 ....: 

In [12]: printName()
hello world

In [13]: printName().__doc__
hello world

In [14]: printName.__doc__
Out[14]: 'test function'

 运算符：
 索引运算符：[i]可以使用负数，即倒着取值
 切片运算符：[i:j]
 扩展切片:[i:j:stride]
In [15]: str1 = "www.xionghaier.com"

In [16]: str1[0]
Out[16]: 'w'

In [17]: str1[1]
Out[17]: 'w'

In [18]: str1[2]
Out[18]: 'w'

In [19]: str1[3]
Out[19]: '.'

In [20]: str1[0:]
Out[20]: 'www.xionghaier.com'

In [21]: str1[0:6]
Out[21]: 'www.xi'

In [22]: str1[0:6:2]
Out[22]: 'wwx'
 支持运算
 索引，切片，min(),max(),len()等
 支持操作
 对象自有的操作

1.7适用于字符串的操作

Python2提供两种字符串对象类型

字节字符串：字节（8bit数据）序列

Unicode字符串：Unicode字符（16bit数据）序列

Python可以使用32bit数据保存Unicode字符，但此为可选特性

s.captitalize()                 首字符变大写
s.index('sub' [,start[,end]])   找到指定子字符串sub首次出现的位置，否则报错，[]中括号里为可选参数
s.join(t)                       使用s作为分隔符连接序列t中的字符串
s.lower()                       转换为小写形式
s.replace(old,new[,maxreplace]) 替换一个子字符串
s.split([sep [,maxsplit]])      使用sep作为分隔符对一个字符串进行划分。maxsplit是划分的最大次数
s.strip([chrs])                 删掉chrs开头和结尾的空白或字符
s.upper()                       将一个字符串转换为大写形式

案例：
In [47]: l2 = list(str1)
In [48]: print l2
['w', 'w', 'w', '.', 'x', 'i', 'o', 'n', 'g', 'h', 'a', 'i', 'e', 'r', '.', 'c', 'o', 'm']
In [51]: ''.join(l2)
Out[51]: 'www.xionghaier.com'

列表：
 容器类型
 任意对象的有序集合，通过索引访问其中的元素，可变对象
 异构，任意嵌套

 支持在原处修改：
 修改指定的索引元素，修改指定的分片，删除语句，内置方法
In [68]: l3 = [1,2,3,4,5]

In [69]: print l3
[1, 2, 3, 4, 5]

In [70]: l3[1] 
Out[70]: 2

In [71]: l3[1] = 32

In [72]: print l3
[1, 32, 3, 4, 5]

In [74]: l3[3] = 'xyz'

In [75]: print l3
[1, 32, 3, 'xyz', 5]

In [76]: l3[1:3]
Out[76]: [32, 3]

In [77]: l3[1:3] = []

In [78]: print l3
[1, 'xyz', 5]

In [80]: del(l3[1:])
In [81]: print l3
[1]

In [82]: l3.append(77)

In [83]: print l3
[1, 77]
 l1 + l2:合并两个列表，返回一个新的列表，不会修改原列表
 l1 * n:把l1重复N次，返回一个新列表

 in：成员关系判断字符，用法 obj(元素) in container
 not in： obj not in container

 字典：dict
 字典在其他编程语言中又称为关联数组或散列表

 通过键实现元素存取，无序集合，可变类型容器，长度可变，异构，嵌套

 {key1:value1,key2:value2,....}

 {}:空字典

 字典复制：d2=d1.copy()

 d1.iteritems:返回一个迭代器对象

In [2]: zip('abc','123')
Out[2]: [('a', '1'), ('b', '2'), ('c', '3')]

In [3]: dict(zip('abc','123'))
Out[3]: {'a': '1', 'b': '2', 'c': '3'}

2.字典、表达式和语句

对于Python而言，每一种数据类型都是由类来进行定义的

表达式：是由一个或多个操作数或零个及以上的操作符所组成的序列就叫做表达式

语句：通常用来实现的操作，常见的操作有，声明变量，变量赋值，调用函数和方法，循环访问及条件判断等

#字典的其它方法
dic1.clear() ##清空字典
dic1.copy(dict2) #拷贝字典
dic3 = dict.fromkeys('abc',1) #快速生成字典
dic1.get() #查询
dic1.items() #生成列表元祖key,value形式
for k,v in dic1.items()
 print(k,v)
dic1.keys() #取出字典所有的key值
dic1.pop("name") #弹出
dic1.popitem() #弹出key对应的value，随机删除
dic1.setdefault('gender','male') #增加key，value
dic1.setdefault("gender",[]).append("male")
dic1["gender"].append("male")
dic1.update(dic1) #更新 dict1 = {"danlce":18000}把次dict1更新到原有的dict1基础上
dic1.values() #取值

ython中的常用的表达式操作符：
 x * y ,x /y ,x+y ,x-y ,x//y,x%y
 
逻辑运算：
 x or y, x and y, not x

 成员关系运算：
 x in y , x noy in y
 对象实例测试
 x is y x not is y
 比较运算：
 x < y,x > y x <= y,x >= y,x == y,x != y
 位运算:
 x|y x& y x^y x<<y,x>>y

 一元运算：
 -x，+x,~x(按位取反)
 幂运算：
 x ** y
 索引和分片
 x[i],x[i:j],x[i:j:stride]

 调用
 x(....)

 取属性：
 x.attribute

 元组：(....)
 序列: [...]
 字典：{...}

 三元选择表达式：x if y else z

 匿名函数： lambda args：expression

 生成器函数发动协议： yield x


运算优先级：
 (....),[....],{.....}
 s[i],s[i:j]
 s.attribute
 s(....)
 +x,-x,~x
 x**y
 * / // %
 + —
 << >>
 &
 ^
 |
 < <= > >= == !=
 is not is
 in not in
 not
 and
 or
 lambda

2.1Python语句

语句：
 赋值语句
 调用
 print：打印对象
 if/elif/else:条件判断语句
 for/else:序列迭代
 while/else：普通循环
 pass：占位符
 break:
 continue
 def
 return
 yield：生成器函数
 global:命名空间
 raise：手动触发异常
 import：
 form：模块属性访问
 class:类
 try/except/finally：捕获异常
 del:删除引用
 assert：调试检查
 with/as:环境管理器

赋值语句：
 隐式赋值：import，from，def，class，for，函数参数

 元组和列表分解赋值，当赋值符号（=）的左侧为元组或列表式，python会按照位置把右边的对象和左边的目标自左向右逐一进行配对，个数不同时会出异常，此时可以进行切片处理

In [5]: w = (1,2,3)
In [6]: (x,y,z) = w
In [7]: print x
1
In [8]: print y
2
 
多重目标赋值：
In [9]: num1 = num2 = num3 = 45

In [10]: print num1
45

In [11]: print num2
45
 增强赋值：+=,-=,*=,/=,//=,%=, 
In [22]: a = 3

In [23]: a += 1

In [24]: print a
4

补充：
 1.动态语言
 sys.getrefcount()

 增加对象的引用计数场景
  对象创建时：
  将对象添加进容器时：lis
  t.append()
  当对象被当作参数传递非函数时
  为对象创建另外的变量名

 减少引用计数 
  引用此对象的某变量名被显示销毁：del x
  引用此对象的某变量名重新赋值
  从容器中移除对象时，类似list.pop()
  容器本身被销毁

2.2字典、元组、集合、字典补充

#集合笔记
linux_set = {"John","xiaoxiao","xiaoming"}
python_set = {"John","xiaoxiao","xiaoming","zhangsan"}

#交集
linux_set.intersection() #instersection相当于&
print(linux_set.intersection(python_set))

#并集
print(python_set|linux_set) #调用的方法python_set.union(linux_set)

#差集
print(python_set-linux_set)
python_set.difference(linux_set)

#对称差集
print(python_set^linux_set)
python_set.symmetric_difference(linux_set)

#子集
python_set.issubset()
print(python_set<=linux_set)

#集合的其它内置方法
s1 = {1,2,3}
s1.update() #更新
s1.add("hello") #增加
s1.pop() #随机删除
s1.remove(1) #指定删除
s1.discard('4') #指定删除的元素没有时不会报错
s1.copy() #拷贝
s1.clear() #清空
s1.difference(s2) #取不同元素#字典字典增删改查

dic1 = {}
dic1["name"]="John"
print(dic1)
#shan
# del dic1["name"]
# print(dic1)
#gai
dic1["name"]="alex"
print(dic1)
#cha
print(dic1["name"])
print(dic1.get("name"))

#字典的其它方法
dic1.clear() ##清空字典
dic1.copy(dict2) #拷贝字典
dic3 = dict.fromkeys('abc',1) #快速生成字典
dic1.get() #查询
dic1.items() #生成列表元祖key,value形式
for k,v in dic1.items()
    print(k,v)
dic1.keys() #取出字典所有的key值
dic1.pop("name") #弹出
dic1.popitem() #弹出key对应的value，随机删除
dic1.setdefault('gender','male') #增加key，value
dic1.setdefault("gender",[]).append("male")
dic1["gender"].append("male")
dic1.update(dic1) #更新 dict1 = {"danlce":18000}把次dict1更新到原有的dict1基础上
dic1.values() #取值

 

AD：《熊孩子博客》熊孩子QQ:443060965