Python基本数据类型

• 数字
• 组

数字

分为整型、浮点型、布尔型、复数

1. 整型(int)
2. 浮点型(float)
3. 布尔型(bool)
4. 复数(complex)

组

1. 序列

• 字符串(str)
• 列表(list)
• 元组(tuple)

2. 集合(set)
3. 字典(dict)

数字（Number）

• 整型(int)、浮点型(float)

1
type(1)
-1
type(-1)
type(1.1)
type(1.11111111111111111111111111111111)
1+0.1
type(1+0.1)
type(1+1)
type(1+1.0)
type(1*1)
type(1*1.0)
type(2/2)
type(2//2)
1//2

• 进制（十进制、二进制、八进制、十六进制）

1. 如何进位
   逢十进一、 逢二进一、 逢八进一、 逢十六进一
2. 进制表示
   二进制: 0b开头
   八进制: 0o开头
   十六进制:0x开头
3. 案例

0b10
0b11
0o10
0o11
0x10

#转二进制
print(bin(10))
print(bin(0o7))
print(bin(0xE))
#转八进制
print(oct(0b111))
print(oct(0x777))
#转十进制
print(int(0b10))
print(int(0o77))
#转十六进制
print(hex(888))
print(hex(0o777))

2. 其他进制
   比如60s=1minute

• 布尔型(bool)
  bool类型表示真假。

True
False
type(True)
type(False)
int(True)
int(False)
bool(1)
bool(0)

#非0代表True,0假
bool(2.2)
bool(0b01)
bool(0b0)
#其他类型也可以转bool
bool("abc")
bool("")
bool([1,2,3])
bool([])
bool({1,2,3})
bool({})
bool(None)

结论:除了0表示False外，其他类型的空值也为False

• 复数(complex)
  数字后加j

36j

组

现实中总是存在一组一组的事物。

1. 序列

• 字符串(str)

宣室求贤访逐臣，贾生才调更无伦。
可怜夜半虚前席，不问苍生问鬼神。

字符串是由独立字符组成的一个序列，通常包含在单引号（''）双引号（"")）或者三引号之中（''' ''' 或""" """)

'helloworld'
"let's go"
"""hello
world
"""

单引号换行

print("hello\nworld\n")
print('hello \
      world')

转义字符
特殊字符
无法"看见"的字符
与语言本身语法有冲突的字符
常见的转义字符
\n 换行
\' 单引号
\t 横向制表符
\r 回车

思考：print("c\nworld\ntesd")打印: 两行，现在想打印一行即 c\nworld\ntesd如何实现？
答案见末尾。

1）字符串合并

"hello"+"world"
"hello"*3

2）字符串替换

"hello".replace('h','w') ->wello

3）获取单个字符
通过索引获取

'hello'[0] ->h
'hello'[-1] ->o

【-n】:从字符串末尾，往前数n次，获取字符
4）字符串切片
切片 ,左闭右开 [)

"helloworld"[0:4]->hell
"helloworld"[0:-1]->helloworl
#获取world
"helloworld"[5:] -> world

"hello python java javascript ruby go" 仅获取go

"hello python java javascript ruby go" [-2:]

5）字符串格式化
format()

print('name={}age={}'.format("张三",20))
print('name={0}age={1}'.format("张三",20))
print('name={name}age={age}'.format(age=20,name='张三'))

6）查找元素find ，index
通过元素找索引找到第一个就返回，找不到返回-1

a="javascript"
print(a.find('a')) # 1
print(a.find('m')) # -1
print(a.index('v'))# 2

7）split 把字符串分割成列表

s = 'java python go'
s1 = 'java;x python;sir bar;ryy'

print(s.split()) #['java', 'python', 'go']
print(s1.split(";"))# ['java', 'x python', 'sir bar', 'ryy']

8）join()
join将序列中的元素以指定的字符连接生成一个新的字符串

s = 'alex' ####看成字符列表
li = ['aa', 'ddj', 'kk']    #### 必须全是字符串
s1 = '_'.join(s)
print(s1)
s2 = ' '.join(li)
print(s2)

• 列表(list)
  1）列表概念
  实际上，列表和元组，都是一个可以放置任意数据类型的有序集合
  2）列表的创建
  []表示空列表

[1,2,3]

使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表

list("abc") 
['a', 'b', 'c']

3）在绝大多数编程语言中，集合的数据类型必须一致。不过，对于 Python 的列表和元组来说，并无此要求：

l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素
l
[1, 2, 'hello', 'world']

tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素
tup
('jason', 22)

列表的元素还可以是列表，称为嵌套列表

[[1,2],[3,4],[True,False]]

2,列表操作
2.1 列表增加

• 列表元素添加-append()
  向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。 例如：

x = [1，2，3]
x.append(4)
x
[1,2,3,4]

• 列表元素添加-insert()
  向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。

x = [1,3,4]
x.insert(1,2)
x
[1,2,3,4]

• 列表元素添加-extend()
  将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。

x = [1,2]
x.extend([3,4])
x
[1,2,3,4]

2.2运算符"+"和*
并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。

• 列表加法

[1,2,3]+[4,5,6] 
 [1,2,3,4,5,6]

• 列表乘法

x=[1,2,3]
y=x*3
y
[1,2,3,1,2,3,1,2,3]

此时x保持不变，依旧是[1,2,3]

[1,2,3][0] ->1
[1,2,3][0:2]-> [1,2]
[1,2,3][-1:]->[3]  注意：结果是列表 

2.3列表元素删除

• pop()
  使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常。

x = [1,2,3,4]
x.pop()   #弹出并返回尾部元素
x.pop(1) #弹出并返回指定位置的元素
2

• remove()
  删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

x = [1,2,2,3,4]
x.remove(2)
x
[1,2,3,4]

• clear()
  清空列表

x = [1,2,3,4]
x.clear()
x
[ ]

• del()
  删除列表中的指定位置上的元素。

x = [1,2,3,4]
del x[1]
x
[1,3,4]

2.4列表中常用内置函数

• len()
  返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。

• max()、 min()
  返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。

• sum()
  对列表的元素进行求和运算。

• zip()
  返回可迭代的zip对象。

• enumerate()
  枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

for item in enumerate('abcdef'):
print(item)
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
 (5, 'f')

2.5遍历列表的三种方式

a = ['a','b','c','d','e','f']
for i in a:
    print(i)

for i in range(len(a)):
    print(i,a[i])
for i,ele in enumerate(a):
    print(i,ele)

• 元组(tuple)
  元组属于不可变序列，一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。

1）元组的创建

(1,2,3,4,5)
(1,2,3,4,5)[0]
(1,2,3,4,5)[0:]
(1,2,3,4,5)+(6,7) 
 (1,2,3,4,5,6,7)
(1,2,3)*3
（1,2,3,1,2,3,1,2,3）

思考题:
type((1)) ，type(('helo'))，结果是？为什么？

原因; （）既可以表示数学运算，也表示了元组，在这个例子中，编译器不知道()表示什么，就按照数学运算表示了。
那么，如何定义只有一个元素的元组呢？

(1，)
type((1,))->tuple

2) 使用tuple函数将其他序列转换为元组

tuple("abc")
('a', 'b', 'c')

3)元组的优点

• 元组的速度比列表更快。
• 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
• 元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。

总结：
1). 实际上，列表和元组，都是一个可以放置任意数据类型的有序集合
2). 列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素（mutable）。而元组是静态的，长度大小固定，无法增加删减或者改变（immutable）。

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

3.增加元素，列表用append（)而元组只能创建新的元组。
4）str list tuple都是序列；

序列特点：
1）都可以通过索引访问
2)都具有切片功能

"helloworld"[0:8:2]

3)in关键字判断元素是否在序列中

3 in [1,2,3,4] ->True
3 not in [1,2,3] -> False

4)序列长度、最大值、最小值

len([1,2,3]) ->3
max([1,2,5])->5
min([1,2,5])->1

ASCII码值：

ord('a')

列表和元组常用方法

l = [3, 2, 3, 7, 8, 1]
l.count(3) 
l.index(7)
l.reverse()
l.sort()

tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
tup.index(7)
list(reversed(tup))
sorted(tup)

count(item) 表示统计列表 / 元组中 item 出现的次数。
index(item) 表示返回列表 / 元组中 item 第一次出现的索引。
list.reverse() 和 list.sort() 分别表示原地倒转列表和排序（注意，元组没有内置的这两个函数)。
reversed()和 sorted() 同样表示对列表 / 元组进行倒转和排序，但是会返回一个倒转后或者排好序的新的列表 / 元组。

2. 集合(set)
   1）集合的定义
   集合是无序可变序列，使用一对大括号界定，元素不可重复，同一个集合中每个元素都是唯一的。集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据。
   2）集合的创建

{}
{1,2,3}

定义空集合

{} 
set()

3）集合元素的增加与删除

• 增加元素
  使用add()方法为集合添加新元素，如果该元素已存在于集合中则忽略该操作。

s = {1,2,3}
s.add(3)
s
{1,2,3}

使用update()方法合并另外一个集合中的元素到当前集合中

s = {1,2,3}
s.update({3,4,5})
s
{1,2,3,4,5}

• 删除元素
  当不再使用某个集合时，可以使用del命令删除整个集合。集合对象的pop()方法弹出并删除其中一个元素，remove()方法直接删除指定元素，clear()方法清空集合。

 a = {1, 4, 2, 3}
 a.pop()
1
 a.pop()
2
a
{3, 4}
 a.add(2)
 a
{2, 3, 4}
 a.remove(3)
 a
{2, 4}

4)集合操作
移除集合中的元素, "-"号求差集

{1,2,3,4} -{3,4} ->{1,2}

求交集

{1,2,3,4} & {3,4} ->{3,4}

求并集

{1,2,3,4} | {3,4} ->{1,2,3,4}

tip
集合无法通过下标和切片访问

s={1,2,3}
print(s[0])

Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/movie/core.py", line 4, in <module>
    print(s[0])
TypeError: 'set' object does not support indexing

3. 字典(dict)

   
   

1)字典概念
字典(dictionary)是包含若干“键：值”元素的无序可变序列，字典中的每个元素包含“键”和“值”两部分，定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。字典中的键可以为任意不可变数据，比如整数、实数、字符串、元组等等。
2）字典的创建

{} #空字典
{1:1,2:2}
type({1:1,2:2})

3)字典元素的读取
以键作为下标可以读取字典元素，若键不存在则抛出异常

{"q":1,"w":2}["q"]->1

使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。

a={"name":"张三"}
print(a.get("name"))
a={"name":"张三"}
print(a.get("age",20))

使用字典对象的items()方法可以返回字典的键、值对列表

a={"name":"张三"}
print(a.items()) # dict_items([('name', '张三')])

使用字典对象的keys()方法可以返回字典的键列表

a={"name":"张三","age":21}
print(a.keys()) # dict_keys(['name', 'age'])

使用字典对象的values()方法可以返回字典的值列表

a={"name":"张三","age":21}
print(a.values()) # dict_values(['张三', 21])

使用字典对象的setdefault()方法返回指定“键”对应的“值”，如果字典中不存在该“键”，就添加一个新元素并设置该“键”对应的“值”,如果字典中存着该"键"，就不做任何操作，只是返回该"键"在字典中的值。

a={"name":"张三","age":21}
re=a.setdefault("sex","male")
print(re)  #male
print(a.values()) # dict_values(['张三', 21, 'male'])

4）字典元素的添加
当以指定键为下标为字典赋值时，若键存在，则可以修改该键的值；若不存在，则表示添加一个键、值对。

person={"name":"张三","age":21}
person['name']="lisi"
person["sex"]="male"
print(person)

5)字典删除

• 字典clear()方法
  clear()方法是用来清除字典中的所有数据，因为是原地操作，所以返回None（也可以理解为没有返回值）

person={"name":"张三","age":21}
person.clear()
print(person) # {}

• 字典pop()方法
  pop()删除指定给定键所对应的值，返回这个值并从字典中把它移除。

x = {'a':1,'b':2}
print(x.pop('a')) # 1
print(x) #{}

• 字典popitem()方法
  字典popitem()方法作用是：随机返回并删除字典中的一对键和值（项）。为什么是随机删除呢？因为字典是无序的，没有所谓的“最后一项”或是其它顺序。在工作时如果遇到需要逐一删除项的工作，用popitem()方法效率很高。

x = {'a':1,'b':2}
print(x.popitem()) # ('b':2)
print(x) #{'a':1}

6）判断一个key是否在字典中
使用in方法

#生成一个字典
d = {'name':'tom', 'age':10, 'Tel':110}
#打印返回值，其中d.keys()是列出字典所有的key
print ('name'  in d.keys())
print ('name' in d)
#两个的结果都是返回True

7）字典遍历

• 遍历key值

{'a': '1', 'b': '2', 'c': '3'}
for key in a:
       print(key+':'+a[key])
a:1
b:2
c:3

• 遍历value值

for value in a.values():
       print(value)

• 遍历字典项

for kv in x.items():
    print(kv)

• 遍历字典健值

for (k,v) in x.items():
    print("k={},v={}".format(k,v))

tip:
在字典中，key不能相同,且必须是不可变的类型
思考：下面两个字典，有什么问题？

{[1,2]:1}
{(1,2):1}

答案
方法一： print('c\nworld\ntest')
解决方法2： print(r'c\nworld\ntest') ->加入r后，变成原始字符串，\不具备转义字符能力