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或者False

print(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]))