python语法之基础数据类型

一、整型

1、用途：一般用于定义整数，如：年龄，身份证号，qq号码等

2、定义方式：age = 18   ---->age = int( 18 )

3、内置常用方法 （用于数学计算与比较运算）

3.1 进制的转换

3.1.1  其他进制转换10进制

二------->十： （0，1 ）

110   1*（2**2）+ 1*（2**1） +0*（2**0）=4+2+0=6

         print（int ( ' 110 ' ,2 ) ）

 

八------->十： （0-7 ）

123   1*（8**2）+ 2*（8**1） +3*（8**0）=64+16+3=83

         print（int ( ' 123 ' ,8 ) ）

 

十六------->十： （0-9，a-f ）

321   3*（16**2）+ 2*（16**1） +1*（16**0）=768+32+1=801

         print（int ( ' 321 ' ,16 ) ）

 

3.1.2  10进制转换其他进制（0-9）

十------->二：  print（bin (108 ) ） ------->0b1101100

十------->八：   print（oct ( 83 ) ）------->O0123

十------->十六：   print（hex ( 1000 ) ）------->Ox3e8

4、总结

1、（有索引的类型都是有序的）

2、不可变

3、存一个值

 

二、浮点型

1、用途：用于记录小数，身高，体重，薪资等

2、定义方式：height = 1.0 ----> height = float(1.0)

3、内置常用方法

 s1 = '1.0'
 f1 = float(s1)
 print(f1)       # 1.0
 print(type(f1))   # float
 a1 = int(f1)
 print(a1)    # 1

4、总结

1、无序

2、不可变类型

2、只能存一个值

 

三、字符串

1、用途：用于存储一些描述性信息，名字等

2、定义方式

 第一种：
s1 = '大象'

第二种：
 s2 = "大象2"

 第三种：

s3 = '''大象3'''

s4 = """大象4"""

print(s1,s2,s3,s4)

# 以上三种方式没有任何区别，但是不能混用

s5 = '你今天"吃饭"了吗'

# 补充：字符串前面加一个小写的r，代表转义

3、内置常用方法

1、索引取值（正向取、反向取），只能取不能存

s1 = 'hello world'

print(s1[4])  # 正向取
print(s1[-7]) # 反向取

2、索引切片  ： 截取字符串中的一小段字符串

 print(s1[2:5])
 print(s1[4:])
 print(s1[:5])
 print(s1[0:-2:2])
 print(s1[::-1])

3、成员运算：in  not in

print("o" not in s1)

4、strip :去除字符串左右两边的空格，中间不算
 input无论接受的是什么类型，一定返回的是字符串

 name = input(">>:").strip()
 print(len(name))

 a1 = '$$$$sean$$$'
 print(a1.strip("$"))

5、split : 切分: 对字符串进行切分，可以指定切分的分隔符，返回是一个列表

 a1 = 'sean 18 male'

print(a1.split())

6、len() :获取当前数据中的元素的个数

a1 = 'hello'

print(a1)

#for循环
a1 = 'hello'
for i in a1:
     print(i)

#需要掌握知识点：
strip，rstrip,lstrip

inp = input(">>:").lstrip("*")
print(inp)
print(len(inp))


# lower\upper
s1 = 'Hello world'
print(s1.upper())
print(s1.lower())


# startswith\endswith  : 判断当前字符串是否以。。。开头，或者以。。结尾，返回的一定是布尔值
print(s1.startswith("He"))

print(s1.endswith('ld'))

.format()
你的名字是：sean，你的年龄是：18

name = 'sean'
age = 19

print("你的名字是:",name,"你的年龄是,",age)

print("你的名字是：{}，你的年龄是：{}".format(name,age))

print("你的名字是：{1}，你的年龄是：{0}".format(name,age))

print("你的名字是：{name}，你的年龄是：{age},{gender}".format(age=age,name=name,gender='male'))

# f-string:
# 通过大括号接收变量，在字符串前面一定要加一个小写f，，，，在python3.6以后才有
print(f"你的名字是：{name}，你的年龄是：{age}")

# split\rsplit
s1 = "name,age,gender"
print(s1.split(",",1))  # 可以指定切分的次数

# join : 将（列表）中每个元素按照前面字符串中的分隔符进行拼接
l1 = ['sean','18','male']
print("|".join(l1))

# replace：将字符串中的元素进行替换，参数，先老值，再新值
s1 = 'sean,18'
print(s1.replace("sean",'大象'))


# isdigit() ： 判断当前字符串中的数据，是否是一个数字，返回布尔值

score = input("please input your score:")
if score.isdigit():
    score = int(score)
     if score >= 90:
         print('优秀')
else:
     print("你tmd能不能好好输")

4、总结

1、有序

2、不可变类型

2、只能存一个值

 

四、列表

1、用途：用于存一个或者多个不同类型的值

2、定义方式：通过花括号存值，每个值之间通过逗号进行分隔

3、内置常用方法

# 1、索引取值(正反都可以)，不仅可以取还可以存
l1 = [1, 2, 3, 4, 5]
print(l1[2])  # 3
# l1[2] = 222
# print(l1)  # [1, 2, 222, 4, 5]


#2、索引切片
print(l1[1:4])  # [2, 3, 4]


#3、append() 追加  只能添加到列表的最后一位,一次性只能添加一个值
l1.append(1000)
print(l1)
l1.append([9, 8])
print(l1)

#4、insert()    插入值，通过索引指定插入的位置
l1.insert(3, 888)
print(l1)

#5、extend()   将插入的可迭代对象分别插入
l1.extend([33, 44, 55])
print(l1)

#6、reomve()  指定值删除，比较彻底,()中直接放值
l1.remove(1)
print(l1)
l1.remove([9, 8])
print(l1)

#7、pop()  不传值，默认从最后开始删，指定索引删值,pop是有返回值的
val = l1.pop()
print(val)

 

4、队列：先进先出

      堆栈：先进后出

#队列

# l = []
# l.append(1)
# l.append(2)
# l.append(3)
# print(l)
# #[1, 2, 3]
# l.pop(0)
# print(l)
# #[2, 3]
# l.pop(0)
# print(l)
# #[3]
# l.pop(0)
# print(l)
# #[]

#堆栈

l = []
l.append(1)
l.append(2)
l.append(3)
print(l)
#[1, 2, 3]
l.pop()
print(l)
#[1, 2]
l.pop()
print(l)
#[1]
l.pop()
print(l)
#[]

 

 

#深浅copy

import copy
l1 = [257, 'a', [4, 5, 6]]
print(l1)
print(id(l1))
# print(id(l1[0]))
l2 = copy.deepcopy(l1)  # [1, 'a', [4, 5, 6]]
l2[2][0] = 4444
print(l2)
print(id(l2))
print("l1:", l1)
print("id_l1:", id(l1))

 

5、总结

1、有序

2、可变类型

2、存多个值

 

五、元祖 tuple

1、用途：用于存多个不同类型的值,不能存可变类型（列表）

2、定义方式：通过小括号存数据，数据之间用逗号分隔，值不可变，有索引。

                       #若容器里只有一个值，值的后面要加上逗号，否则返回字符串。

3、常用方法

#索引取值（正，反）
t = ('a','b','c','d')
print(t[0])   #a
print(t[-1])  #d

#索引切片
print(t[0:2])   #('a', 'b')

#in/ not in
print('a' in t)  #True

#len()
print(len(t))  #4

#for
for i in t:
    print(i)
# a
# b
# c
# d

4、总结

1、有序

2、不可变类型

2、存多个值

 

六、字典 dict

1、用途：用于存多个不同类型的值,不能存可变类型（列表）

2、定义方式：通过花括号存数据，通过key：value来定义键值对数据，每个键值对中间用逗号分隔。

                      #key在定义时必须是不可变类型，value可以是任意类型。

三种定义方式：

#  第一种
d1 = {'name':'nick', 'age':18}

#  第二种
d2 = dict('name':'nick', 'age':18)

#  第三种 zip
l1 = ['name','age']
l2 = ['nick',18]
z1 = zip(l1,l2)
print(dict(z1))  #{'name': 'nick', 'age': 18}

3、方法

# 按照key：value映射关系取值（可存可取）

d1 = {'name': 'nick', 'age': 18}
# print(d1['name'])  #nick 取值

# d1['name'] = 'bonny'
# print(d1)   # {'name': 'bonny', 'age': 18}   改值

# d1['gender'] = 'male'
# print(d1)   # {'name': 'nick', 'age': 18, 'gender': 'male'}   添值

# in/ not in  默认判断key
print('name' in d1)  # True

#len() 获取键值对的个数
print(len(d1))  #2

内置方法

# get() 获取key的值，若值不在，默认返回none

d1 = {'name': 'nick', 'age': 18}

# a= d1.get('xxx',123)  #key不存在，可以设置默认返回值
# print(a)   #123

print(d1.get('age'))  # 18
print(d1.get('gender'))  # None

#keys / values / items
print(d1.keys())   # ['name', 'age']  返回列表
print(d1.values())   # ['nick', 18]   返回列表
print(d1.items())   # [('name', 'nick'), ('age', 18)]  返回列表套元祖，每一个item都是存在元祖

for key in d1:
    print(key)    
#name         #默认遍历的是字典的key
#age  

for key in d1.keys():
    print(key)
#name
#age

for value in d1.values():
    print(value)
#nick
#18

for item in d1.items():
    print(item)
#('name', 'nick')
#('age', 18)

#pop 指定key删，有返回值，值为对应value
d1 = {'name': 'nick', 'age': 18}
a= d1.pop('name')
print(d1)  # {'age': 18}
print(a)  # nick

#popitem() 随机删一组item，有返回值，值是元祖
d1.popitem()
print(d1)

#update() 用新字典替换旧字典，有则修改，无则添加
d1.update({'name':'peter'})
print(d1)   # {'name': 'peter', 'age': 18}  修改

d1.update({'b': 1})
print(d1)     #{'name': 'nick', 'age': 18, 'b': 1} 添加

#fromkeys()  生成一个新字典
d2 = {}
d2 = d2.fromkeys([1, 2, 3], 'e')
print(d2)   # {1: 'e', 2: 'e', 3: 'e'} 


#setdefault() key不存在时新增item，有返回值，返回新增value，key存在，返回对应value
d1 = {'name': 'nick', 'age': 18}
d3 = d1.setdefault('d', 999)
print(d3)    # 999
print(d1)   # {'name': 'nick', 'age': 18, 'd': 999}  key不存在时新增item有返回值

d4 = d1.setdefault('name', 888)   #key存在，返回对应value
print(d4)  #nick

4、总结

无序

可变类型

存多个值

 

 

七、集合 set

1、用途：去重、关系运算

2、定义方式：通过大括号存储数据，每个元素通过逗号分隔.

                        定义空集合，必须使用set()来定义

                       

# l1 = []
# s1 = ""
# d1 = {}
# ss1 = set()    # 定义空集合

frozenset() 不可变集合

3、常用方法

s1 = {'a', 'b', 'c', 'd', 'e', 'e'}
s2 = {'c', 'b', 'f', 'd', 'g'}

print(s1) #{'a', 'c', 'b', 'd', 'e'} 去重

print(s1 | s2)  #{'c', 'g', 'a', 'b', 'e', 'd', 'f'} 合集

print(s2 & s1)  #{'d', 'b', 'c'}  交集

print(s1 - s2)  #{'a', 'e'}  差集

print(s2 - s1)  #{'g', 'f'}  差集

print(s1 ^ s2)  #{'g', 'f', 'e', 'a'} 对称差集

print(s1 > s2)  #False

print(s2 > s1)  #Fals

 

4、总结

无序

可变

存多个值

 

八、总结

存一个值：整型、浮点型、字符串
存多个值：列表、元组、字典、集合

可变or不可变：
可变： 列表，字典
不可变：整型、浮点型、字符串、元组、集合

有序or无序：
有序：字符串、列表、元组
无序：字典、集合

占用空间：
字典
列表
元组
集合
字符串
数字类型