day02 python数据类型
python里面常见的数据类型
目录
一、int 整形只有一个方法bit_length() 可以显示二进制长度
a = 10
b = a.bit_length()
print(b)
1010
二、bool
bool -> 数据类型之间的转化(记结论)
int(字符串) => 把字符串转化成数字
str(数字) => 把数字转化成字符串
结论1: 想要把x变成y y(x)
结论2: 所有的空都表示False, 所有的非空都表示True
三、string
字符串的索引
程序员数数从0开始
字符串[索引]
切片:
字符串[start:end] 从start到end拿到数据. end取不到
daily = "周一周五上班周末上课，干不完的活还有堆学不会的东西并且还有一些额外的烦恼，so我们要学会调整自己"
print(daily[0:5])
ps: 如果想取到第六个值那么需要把end往后加一（俗话称顾头不顾尾）
字符串[start:end:step] 从start到end拿数据. 每step个拿出来一个.
daily = "周一周五上班周末上课，干不完的活还有堆学不会的东西并且还有一些额外的烦恼，so我们要学会调整自己"
print(daily[::2])
按照步长切片
step:
+ 左到右
daily = "周一周五上班周末上课，干不完的活还有堆学不会的东西并且还有一些额外的烦恼，so我们要学会调整自己"
print(daily[0:10:2])
- 右到左
daily = "周一周五上班周末上课，干不完的活还有堆学不会的东西并且还有一些额外的烦恼，so我们要学会调整自己"
print(daily[10:0:-2])
方法：capitalize() 标题第一个英文单词首字母大写
title = "today is monday"
print(title.capitalize())
方法：upper（）全部字母大写
title = "today is monday"
print(title.upper())
验证码例子：
verify_code = input("请输入AppLy: ")
verify_code1 = "AppLy"
if verify_code.upper() == verify_code1.upper():
print("正确")
else:
print("错误")
方法：lower（）把字母转成小写
title = "TODAY IS monday"
print(title.lower())
方法：center()把字符串拉长成10个单位,让原来的字符串居中
name = "张无忌"
name1 = name.center(10,"?")
print(name1)
方法：expandtabs()改变tab的 长度
greating = "你好啊、\t 我叫ivy wang"
print(greating.expandtabs(30))
方法：strip（）去掉字符串两边的空白，lstrip() 去掉左边 rstrip（）去掉右边。
s = " what's your name "
print(s.strip())
方法repalce() 替换字符串
s = "I need a pen"
print(s.replace("need","want"))
方法：split() 以什么为分隔符切割，切割出来的结果是列表的形式
s = "北京#朝阳#丰台#东城#西城"
s2 = print(s.split("#"))
方法:startswith()以什么开头,endswith()以什么结尾。 ps:主要做判断用结果会返回True或者Falseprint(s.startswith("python"))
print(s.endswith("语言"))
方法：conut()统计字符串里某个字符出现的次数
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
print(s.count("生"))
方法：find（）返回索引如果没有返回-1
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
print(s.find("爱"))
方法index()返回索引如果没有则报错
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
print(s.index("可"))
方法：isalpha（） 判断是不是字母
s = "1234"
print(s.isalpha())
方法：isdigit() 判断是不是阿拉伯数字
s = "1234"
print(s.isdigit())
方法：isalnumberic()判断是不是字母和阿拉伯数字
s = "1234aaa"
print(s.isalnum())
方法：len()内置函数和print类似，主要用来查看字符串长度
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
print(len(s))
小例子：用for循环来遍历字符串
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
for i in s:
print(i)
index = 0
s = "生命诚可贵，爱情价更高，若为自由故，两者皆可抛。生命高于爱情还是爱情高于生命"
while index <= len(s):
print(s[index])
index += 1
四、列表
列表的定义： list = [ ] ps：用中括号来表示
lst = ["name","age","address","habby","number"]
print(lst)
ps:索引跟字符串类似
添加一：append() 默认从末尾插入
lst = ["name","age","address","habby","number"]
lst.append("job")
print(lst)
添加二：insert() 指定索引添加
lst = ["name","age","address","habby","number"]
lst.insert(1,"firsr_name")
print(lst)
添加三：extend（）把元素拆开进行迭代添加
lst = ["name","age","address","habby","number"]
lst.extend("second_name")
print(lst)
删除一：pop()默认从末尾删除，也可以指定索引删除
lst = ["name","age","address","habby","number"]
lst.pop()
print(lst)
lst = ["name","age","address","habby","number"]
lst.pop(1)
print(lst)
删除二: remove（）指定元素删除
lst = ["name","age","address","habby","number"]
lst.remove("age")
print(lst)
删除三: del() 指定下标删除
lst = ["name","age","address","habby","number"]
del lst[2]
print(lst)
删除四: clear()删除全部。 ps：一般不建议使用这个方法
lst = ["name","age","address","habby","number"]
lst.clear()
print(lst)
修改：使用索引去修改
lst = ["name","age","address","habby","number"]
lst[0] = "firstname"
print(lst)
把name变成大写的
lst = ["name","age","address","habby","number"]
lst[0] = "firstname".upper()
print(lst)
小例子：让用户输入一个加法运算: 3+8+4+6+9 想办法完成数学运算
Sum = 0
s = "3+8+4+6+9"
verify_code = input("请输入3+8+4+6+9的和: " )
s1 = s.split("+")
for item in s1:
Sum += int(item)
if verify_code == Sum:
print("正确")
else:
print("失败")
列表排序
lst = [99,1,101,88,78]
lst.sort(reverse=False)
print(lst)
倒序
lst = ["香蕉","苹果","西瓜"]
lst.reverse()
print(lst)
查询：查询的方法跟字符串的一样
直接用索引查找和使用for循环可以遍历列表
五、元组元组(tuple): 不可变的列表, 只读列表
放一些不进行修改的数据
元组用()表示.
空元组必须用tuple()来创建
小知识点: 如果元组只有一个元素. 必须在末尾添加一个逗号
定义空元组：
t = tuple()
print(t)
按步长查看元组元素
t = ("哈哈", "周杰伦", "爱上了", "冯提莫")
print(t[1::2])
for循环遍历
for i in t:
print(i)
元组里面的列表可以追加元素
t = ("张无忌", "张大大", ["呵呵", "哈哈", "吼吼"], "张伯伦")
t[2].append("牛A") # 元组的不可变指的是内存指向的不可变
print(t)
把元组赋值给其他变量对原来的元组的列表进行修改
t = ("张无忌", "张大大", ["呵呵", "哈哈", "吼吼"], "张伯伦")
t1 = t[2][1] = "嘻嘻"
print(t1)
定义元组时注意事项
t = (1) # 此时的小括号表示优先级并不是元组
print(type(t))
print(t)
t = (1,) # 当定义一个元组的时候需要加逗号来标识
print(type(t))
print(t)
六、字典
查询速度快
在存储数据的时候必须使用key:value的形式进行存储,
key不可以重复.
并且要求key必须可哈希-> 不可变(int, str, tuple, bool, float)
value没有要求
新增一：直接用新key添加
dic = {"name":"汪峰"}
print(type(dic))
定义一个空字典
dic1 = {}
在已有的字典里面继续添加
dic = {"name":"汪峰","wife":"章子怡"}
dic["赵本山"] = "刘老根"
print(dic)
已经存在的key不可以修改key的value
dic = {"name":"汪峰","wife":"章子怡"}
dic["赵本山"] = "刘老根"
print(dic)
dic["赵本山"] = "阿水" # key 不可以重复. 会把数据覆盖掉
方法：setdefault() 当key在字典中存在的时候, 不执行新增。当key不存在的时候. 执行新增操作。不论新增与否. 执行完新增流程之后. 使用key把value查询出来
dic = {"name":"汪峰","wife":"章子怡"}
dic.setdefault("job","actor")
print(dic)
setdefault应用小例子 把[11,22,33,44,55,66,77,88] 大于66的放到key2 小于66的放到key1
lst = [11,22,33,44,55,66,77,88]
dic = {}
for item in lst:
if item < 66:
if dic.get("key2") != None:
dic["key2"].append(item)
else:
dic['key2'] = []
dic['key2'].append(item)
#dic.setdefault("key2", []).append(item)
else:
if dic.get("key1") != None:
dic["key1"].append(item)
else:
dic['key1'] = []
dic['key1'].append(item)
#dic.setdefault("key1", []).append(item)
print(dic)
lst = [11,22,33,44,55,66,77,88]
dic = {}
for item in lst:
if item < 66:
dic.setdefault("key2", []).append(item)
else:
dic.setdefault("key1", []).append(item)
print(dic)
查询数据的方法
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
print(dic.get("意大利")) ps:查询不到结果时候返回none
查不到结果的时候会报错
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
print(dic["意大利亚"])
只能查key
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
for item in dic:
print(item)
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
for k in dic.keys():
print(k)
只能查value
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
for v in dic.values():
print(v)
key和value一并查询
dic = {
"name":"Ivy","national":["中国","美国","英国"]
}
for k,v in dic.items():
print(k,v)
解构，解包
a, b = (1, 2)
print(a,b)
字典嵌套小例子：
wangfeng = {
"name":"汪峰",
"age":45,
"job":"singer",
"wife":{
"name":"章子怡",
"job":"actress",
"habby":["汪峰","当导师"]
},
"chidren":[
{ "name":"大娃","age":10},
{"name":"二娃","age":5},]
}
print(wangfeng)
查询his wife's job
print(wangfeng['wife']["job"])
把汪峰第三个孩子的年龄增加10
(wangfeng['chidren'][1]["age"]) = wangfeng['chidren'][1]["age"] + 10
print(wangfeng)
追加元素
wangfeng["wife"]["habby"].append("上课看小说")
print(wangfeng)
删除key
删除:
1. pop(key) 指定key删除
2. popitem() 删除最后一个.
3. del dic[key]
4. clear()
修改:
dic[老key] = 新value
查询:
get(key) 使用key获取value
dic[key] 查询, 如果key不存在. 会报错
循环:
for k in dic:
k
dic[k]
for k, v in dic.items():
print(k)
print(v)
九. 知识点补充
1. range：range让for循环数数
for i in range(10): # 从0到9
print(i)
for i in range(10, 20): # 10-19
print(i)
for i in range(10, 20, 2): # 10 12 14 16 18
print(i)
lst = ["手机","callji","lunchuan","dnfyouxibi","有课一乐",11111,111111111111]
for i in range(len(lst)): # 遍历列表, 可以拿到索引和元素
print(i+1, lst[i])
2. join：把列表中每一项拼接起来
s = "_sb_".join(["alex", "太白", "太黑", "太绿"]) #把列表中每一项拼接起来
print(s)
s1 = "alex_sb_太白_sb_太黑_sb_太绿"
print(s1.split("_sb_"))
3. while...else
count = 1
while count<= 10:
if count == 7:
break
print(count)
count += 1
else: # 必须是while条件不成立的时候. 才会执行else
print("wo shi else")
4. for循环的时候不要删除列表中的内容
这种删除方法会错位所以有一个元素删不掉
lst = ["张无忌", "张国荣", "张三丰", "武则天", "秦始皇"]
for item in lst:
if item.startswith("张"): # 判断是否姓张
for item in lst:
lst.remove(item)
print(lst)
这种办法可以删掉
lst = ["张无忌", "张国荣", "张三丰", "武则天", "秦始皇"]
new_lst = [] # 小本本
for item in lst:
if item.startswith("张"): # 判断是否姓张
# 删除这个人
new_lst.append(item)
for item in new_lst:
lst.remove(item)
print(lst)
欠的: 小数据池 is和==区别, 深浅拷贝, set集合
补充1：小数据池理论
小数据池的作用：为了减轻内存的负担， 重复的使用同一个数据。会存储我们常用的一些字符，主要存储的类型如下：
1. int -5 ~ 256
2. 常用的字符串
3. bool True和FALSE
补充二：id, is, ==
id: 查看两个变量是否指向同一个内存地址
is: 判断两个内存地址是否是一个，如果是返回True 否则返回False.
== : 判断等号两边的数值是否相等。
补充三：set集合
类似字典，但是set只存放key，可哈希，不可变，无重复，无序。（帮助去重）
添加：add()
删除：remove()
没有修改
for循环查询
补充四：深浅拷贝
拷贝的意义：快速的创建对象、克隆。
浅拷贝：只拷贝第一层内容，复制一个表面。更深层次的内容只拷贝一个内存地址。
方法一：copy
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
print(id(list1))
list2 = list1.copy()
print(id(list2))
方法二：通过切片的方式
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
print(id(list1))
list2 = list1[:]
print(id(list2))
ps:对于浅拷贝而言，当你修改列表里嵌套的字符时，拷贝过去的那一份数据也会发生变化，原因是它的指向实际上只是一个内存地址
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
list2 = list1[:]
list1[2][0] = "rice5"
print(list1)
print(list2)
深拷贝特点：把内容完全的复制一份
1.import os
2.copy.deepcopy()
import copy
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
list2 = copy.deepcopy(list1)
print(list1)
print(list2)
此时内存地址完全是不一样的，也就意味着不管怎么修改list1 list2都不会发生改变。
import copy
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
list2 = copy.deepcopy(list1)
print(id(list1[2]))
print(id(list2[2]))
注意：赋值操作不会创建新对象，此时内存地址也是一样的。
list1 = ["apple", "orage",["rice", "soup", "sweet"] ,"bananan"]
list2 = list1
print(id(list1))
print(id(list2))
print(id(list1[2]))
print(id(list2[2]))
We are down, but not beaten. tested but not defeated.
