1.python中的数据类型

      python使用对象模型来存储数据，每一个数据类型都有一个内置的类，每新建一个数据，实际就是在初始化生成一个对象，即所有数据都是对象
对象三个特性

• 身份：内存地址，可以用id()获取
• 类型：决定了该对象可以保存什么类型值，可执行何种操作，需遵循什么规则，可用type()获取
• 值：对象保存的真实数据

1.1 数字

定义：a＝1

特性：

1.只能存放一个值

2.一经定义，不可更改

3.直接访问

分类：整型，长整型，布尔，浮点，复数

1.1.1 整型

Python的整型相当于C中的long型,Python中的整数可以用十进制,八进制,十六进制表示。

>>> 10
10         --------->默认十进制
>>> oct(10)
‘012‘      --------->八进制表示整数时，数值前面要加上一个前缀“0”
>>> hex(10)
‘0xa‘      --------->十六进制表示整数时，数字前面要加上前缀0X或0x

字符串转int型：

>>> a = "123"
>>> a
‘123‘
>>> b = int(a)
>>> b
123

浮点型转int型：

>>> a = 1.75
>>> b = int(a)
>>> b
1

1.1.2 布尔型 boolean

True和False

1和0

1.1.3 浮点型float

浮点数即小数，如3.14，1.23，-0.77。
但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23*109就是1.23e9，或者12.3e8，0.000012
可以写成1.2e-5，等等。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有
四舍五入的误差。

1.1.4 数字相关内建函数

1.2 字符串

定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘’‘’中间包含的内容称之为字符串
特性：
1.只能存放一个值
2.不可变
3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r‘l\thf‘
2.unicode字符串与r连用必需在r前面，如name＝ur‘l\thf‘

1.2.1 工厂函数

capitalize() #字符串首字母大写

>>> "hello".casefold()
‘hello‘

 enter() #原来字符居中，不够补全

>>> ‘hello‘.center(20,)
‘       hello        ‘
>>> ‘hello‘.center(20,‘*‘)
‘*******hello********‘

 count() #从一个范围内的统计某str出现次数

>>> "hello".count(‘l‘)
2
>>> "hello".count(‘l‘,0,6)
2
>>> "hello".count(‘l‘,0,2)
0
>>> "hello".count(‘l‘,0,3)
1

endswith() #判断字符串是否以某字符结尾

>>> "hello".endswith("o")
True
>>> "hello".endswith("lo")
True
>>> "hello".endswith("hello")
True
>>> "hello".endswith("k")
False

expandtabs() #将字符串中包含的tab转换成自定义数量的空格

>>> "he\tllo".expandtabs()
‘he      llo‘
>>> "he\tllo".expandtabs(0)
‘hello‘
>>> "he\tllo".expandtabs(4)
‘he  llo‘

find() #返回字符串中指定字符的下标，如果有重复，则只返回第一次找到的

>>> "hello".find("l")
2
>>> "hello".find("l",0,6)
2
>>> "hello".find("l",0,3)
2
>>> "hello".find("k")  #如果字符不在字符串中，返回"-1"
-1

format() #格式化输出

>>> print (‘{0},{1}‘ .format("hel","lo"))
hel,lo
>>> print (‘{0}{1}‘ .format("hel","lo"))
hello
>>> print (‘{}{}‘ .format("hel","lo"))
hello
>>> a,b = "hel","lo"
>>> print (‘{0}{1}‘ .format(a,b))
hello
>>> print (‘{}{}‘ .format(a,b))
hello

index()  #返回字符的下标，如果存在多个，则只返回第一个

>>> "hello".index("l",0,4)
2
>>> "hello".index("l",0,3)
2
>>> "hello".index("l")
2
>>> "hello".index("l",0,2)  #如果字符不在字符串中，则会报异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found

isalnum() #字符串只由字母和数字组成返回true，否则返回false

>>> "hello".isalnum()
True
>>> "hello123".isalnum()
True
>>> "123hello".isalnum()
True
>>> "hello ".isalnum()
False
>>> "".isalnum()
 False

isalpha() #都是字母才返回true

>>> "hello".isalpha()
True
>>> "hello ".isalpha()
False
>>> "hello123".isalpha()
False
>>> "123".isalpha()
False

isdigit()、isdecimal()、isnumerice() #判断字符串是否为数字

num = "1"  #unicode
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = b"1" # byte
num.isdigit()   # True
num.isdecimal() # AttributeError ‘bytes‘ object has no attribute ‘isdecimal‘
num.isnumeric() # AttributeError ‘bytes‘ object has no attribute ‘isnumeric‘

num = "四" # 汉字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

===================
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）

isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）

 islower() 、isupper()、lower()、upper() #判断大小写及转换

>>> "hello".isupper()
False
>>> "HELLO".isupper()
True
>>> "hello".upper()
‘HELLO‘
>>> "HELLO".islower()
False
>>> "HELLO".lower()
‘hello‘

istitle() #判断是否为标题格式

>>> "H".istitle()
True
>>> "Hello World".istitle()
True
>>> "He1".istitle()
True
>>> "He 12".istitle()
True
>>> "Hello world"
‘Hello world‘
>>> "Hello world".istitle()
False
>>> "hello World".istitle()
False

ljust()、rjust() #设定宽度，左、右对齐不全，类似center()

 >>> "hello world".ljust(30,"*")
‘hello world*******************‘
>>> "hello world".ljust(30,"*")
‘hello world*******************‘
>>> "hello world".rjust(30,"*")
‘*******************hello world‘

 split() #以某个字符作为条件，分割字符串，返回列表

>>> "hello world".split()
[‘hello‘, ‘world‘]
>>> "hello world".split("l")
[‘he‘, ‘‘, ‘o wor‘, ‘d‘]

1.3 列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

1.3.1 工厂函数

append() #添加元素到尾部

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

clear() #清空列表

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

copy() #复制一个列表，开辟一块新的内存地址

>>> a
[0, 1, 2, 3]
>>> b = a
>>> id(a)
7413032  #列表a的内存地址
>>> id(b)
7413032  #列表b的内存地址与a相同
>>> c = a.copy()
>>> id(c)
7412512  #列表c的内存地址与a、b不同
>>> a[3] = 4  #修改列表a
>>> a
[0, 1, 2, 4]  #
>>> b 
[0, 1, 2, 4]  #列表b也跟着变了
>>> c
[0, 1, 2, 3]  #列表c没有变

extend() #列表扩展，合并两个列表

>>> a
[1, 2, 3, 1]
>>> b
[1, 2, 3, 1]
>>> a
[1, 2, 3, 1]
>>> a.extend(b)
>>> a
[1, 2, 3, 1, 1, 2, 3, 1]

insert() #往指定位置前插入元素

>>> a
[1, 2, 3, 1, 1, 2, 2, 3, 1]
>>> a.insert(2,"hello")
>>> a
[1, 2, ‘hello‘, 3, 1, 1, 2, 2, 3, 1]

pop() #删除元素并打印该元素

>>> a
[1, 2, ‘hello‘, 3, 1, 1, 2, 2, 3]
>>> a.pop(2)
‘hello‘
>>> a
[1, 2, 3, 1, 1, 2, 2, 3]

remove() #删除元素，参数为元素名称，不是下标

>>> a
[1, 2, 3, 1, 1, 2, 2, 3]
>>> a.remove(1)
>>> a
[2, 3, 1, 1, 2, 2, 3]
>>> a.remove(3)
>>> a
[2, 1, 1, 2, 2, 3]

reverse() #反转列表中元素顺序

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

sort() #排序

>>> a
[0, 3, 5, 1, 4, 7]
>>> a.sort()
>>> a
[0, 1, 3, 4, 5, 7]

 >>> a  #python3中不可以对int和str混合类型的列表排序
[0, 1, 3, 4, 5, 7, ‘hello‘]
>>> a.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()

2.运算符

2.1 算数运算

2.2 比较运算

2.3 赋值运算

2.4 位运算

2.5 逻辑运算

2.6 成员运算

2.7 身份运算

2.8 运算符优先级：自上而下，优先级从高到低

python 3 学习笔记（二）