python修炼第二天

第二天的课程还是塞得满满的，一天下来充实也疲惫。那天听出金星师傅嗓子有些沙哑，想必是讲课说话太多导致。啥也不说了。唯有努力练功方可回报！

1 序：

今天主要是详细学习了绝大部分的数据类型，字符编码，边看金星师傅的视频边记录与练习。日后在详细整理。嘿

知识点有：

　　01 int

　　02 str

　　03 bool

　　04 list

　　05 tuple

　　06 dict

　　07 set

　　08 编码

　　09 数据类型补充

主要就是常用数据类型的操作，增删改查，内置方法等。计算机字符编码的原理，类型，以及字符编码的一些操作,最后是一些数据类型注意的坑，与一些细节原理知识。

2 数据类型

2.1 int 数字

　　int数据类型主要用于计算。

　　定义：  i = 111

　　int的方法：

　　　　bit_length: 将十进制 转换为二进制占得最小位数

　　　　i = 4

　　　　print(i.bit_length())

　　　　结果是4就。4的二进制是0000 0100 ，所以可用位是三位 （100） 同理5 二进制是0000 0101 有效为也是三位（101）。

2.2 bool 布尔值

　　布尔值：True False  真假两个值， 主要是条件判断。

　　布尔值的转换：

　　　　先说一下数字与字符串的转换:

　　　　数字int转换字符串str:  str(int)

　　　　字符串str转换数字int:  int(str) 　 注意字符串必须全部是数字组成才可以。

　　　　数字int转换布尔值bool:  0 就是False   非0 就是True

　　　　布尔值bool转换为数字int:  int(True)  结果是1 ， int(False) 0 结果是0

　　　　字符串str转换为布尔值bool:   print(bool(""))  空字符串是False，  非空字符串True。

2.3 str 字符串

　　被引号引起来的就是字符串。

　　字符串方法：

　　1 upper()  字符全部大写

　　　　s2 = s.upper()

　　2 lower() 字符串全部变小写

　　　　s3 = s.lower()

　　3 swapcase()  大小写翻转

　　　　s4 = s.swapcase()

　　4 title() 非字母元素哥开的每个单词首字母大写

　　　　s = "alex wusir*tom#jack"

　　　　s5 = s.title()

　　5 cennter() 居中

　　　　s.center(30,"*") 填充物默认是空格，也可以自定义 这里是*

　　6 startswith()  以什么为开头，  endswith()   以什么为结尾 。

　　　　s = "oldboy"

　　　　s.startswith("o")

　　　　s.startswith("d",2,5)

　　　　s.endswith("y")

　　　　s.endswith("o")

　　7 strip() 去除前后空格，制表符\t，换行符\n。

　　　　s = " aaa "

　　　　s8 = a.strip()

　　　　print(s8)

　　　　name = input("输入姓名").strip() 后面必须要加这个

　　　　也可以去除字符,循环找字符串中对应的组合

　　　　s = "bdaaaby"

　　　　s.strip("bdy")

　　8 lstrip() 只去左边，　　rstrip() 只去右边

　　　　方法同strip() 只是lstrip()只去左边  rstrip()只去右边。

　　9 split() 分割 str --> list

　　　　s = 'oldboy wustr alex'

　　　　l = s.split() 默认按照空格分割并存储到列表中

　　　　print(l)

　　　　s = "oldboyowustroalex"

　　　　l = s.split("o")

　　　　print(l)

　　10 join()

　　　　s = "oldboy"

　　　　s9 = "+".join(s) 通过连接符吧字符中的元素循环连接

　　　　print(s9)

　　　　同时还可以将列表转换为字符串

　　11 replace() 替换

　　　　s = "大铁锤and 小铁锤"

　　　　s12 = s.replace("铁锤","钢蛋")

　　12 find() ，  index() 通过元素找索引

　　　　s = "abc def"

　　　　s13.find("c")

　　　　print(s) 有2个 只找一个。如果要多找：找到第一个后从第一个位置再往后找。

　　　　s131.index(" ")

　　　　find 找不到就返回-1 如果index找不到会报错 建议找find

　　公共方法： 元祖 列表 字符串

　　1 len()  统计元素个数

　　　　s = "adfasdfsfdfgrtweerewrewd"

　　　　 print(len(s)) 打印出s长度

　　2 count()   统计参数个数

　　　　sp2 = s.count("a") 打印出s中有多少个a

　　3 format()   格式化输出

　　　　res = "我就叫{}今年{}，爱好{}".format("jack",18,"游泳") 按顺序替换方法

　　　　print(res)

　　　　res = "我就叫{0}今年{1}，爱好{2},我依然叫{0}".format("jack",18,"游泳") 下标的方法

　　　　print(res)

　　　　res = "我就叫{name}今年{age}，爱好{hobbie}".format(name="jack",age=18, hobbie="游泳") 键值对的方法

　　4 isdigit 判断数字

　　5 isalpha 判断字母

　　6 isalnum 判断数字

2.4 list 列表

list
1  索引  切片
    li = [1111,"alex",222,"wusir"]
    print(li[1])
    print(li[-1])
    注意 切片取出来的是一个列表
    print(::2)
    步长

2 增 删 改 查
    l = ["老男孩","alex","jack","tom"]
    2.1 增
        1 l.append("小黑")  在最后追加值   l.append([1,2,3])
        2 l.insert(0,"小黑")  在第0索引上插入
        3 迭代这添加
            l.extend("alex")
            print(l)
            把alex 分解为单个元素添加到列表中

    2.2 删
        1 l.pop(0)   按照索引删除 并且返回你删除的值
        2 remove
            l.remove("alex")  按照元素删除
        3 clear
            l.clear()   内容给删除，空列表 但是内存位置还有
        4 del
            del l
            print(l)    在内存中直接删除列表。报错找不到这个l了
            还可以按索引删除
            del l[:3]
            print(l)     删除前3个索引元素
    2.3 改
        1 按照索引改
            l[2] = "武藤兰"
            print(l)

        2 按照切片改
            l[:3]="abc"
            print(l)   删除分片的全部元素， 然后把等号右边的元素，按最小元素添加到列表

    2.4 查
        1 索引查
            l[1]

        2 切片查
            l[1:4]

        3 for 循环查
            for i in l:
                print(i)

3 其他方法
    1 count 统计次数
        ll = [11,22,33,44,55,11,22]
        ll.count(11)    11出现了几次

    2 len 查几个元素
        len(ll)

    3 index   通过元素找索引
        ll.index(22)
        结果是1       可以切片去找

    4 sort 排序
        ll = [7,,4,9,1,2,8]
        ll.sort()               从小到大排
        ll.sort(revers=True)    从大到小排

    5 reversed()  反序
        ll.reversed()

4 列表的嵌套
    ll = [1,2,"alex","wusir",["oldboy","ritian",99],"taibai"]

2.5 tuple

元祖 只读列表 只能读 不能增删改

tu = (1,2,"OK",[1,2,3])
for i in tu
    print(i)

索引
    print(tu(1))
切片
    print(tu[0:3:1]

count   统计元素个数

index   通过元素找索引

len()   统计元祖元素个数

注意 元祖的子级不能修改，元祖的孙子级可以修改
列子：
tu = [1,2,3,4,[1,2,3]]
print(tu[-1].append(4)))

2.6 dict

一 字典定义
        key是唯一的 是二分法  二叉树   key必须是不可变的数据类型
        key: 不可变的数据类型(也叫做可hash) str, bool, tuple, int,
        value: 任意数据类型。
        数据类型分类：
            不可变的数据类型: str bool tuple int
            可变数据类型:     dict list set
            容器类数据类型:   list tuple dict set  存的什么类型，取出来就是什么类型
        字典存储数据多，关系型数据查询速度快（二分查找）
    dict = {"name":"taibai","age":21,"hobby":"girl"}

二 字典的操作
    3.6版本之前都是无序的。 3.6之后字典是有序的。
    1 增
        dict = {"name":"jack","sex":"male"}
        dict["age"]=18      有则覆盖，无则添加
        setdefault
            dict.setdefault("higt",180)
            如果原来有就不变，如果没有就添加新的。

    2 删
        dict.pop("key")   按照键去删  返回删除的值
            有一种情况如果没有key就会报错。这种情况可以在key 后面添加一个默认返回值，没有key就返回返回值
            dict.pop("name1","没有次key")
        dict.clear()      清空字典
        del dict           从内存中全部删除
        del dict["key"]    按照key删除
        popitem  3.6版本前是随机删除。 3.6版本后默认删除最后一个
        dict.popitem()    删除什么就返回什么 并放在一个元祖里面

    3 改
        dict['name']="老男孩"

        update
        dic2.update(dic)  将dic的键值对覆盖到dic2中  dic不变
        print(dic2)

    4 查
        print(dic["name"])   这个方法不好 如果没有 就会报错。

        dict.get("name1","没有次key")  如果没有 就返回返回值 用get

    循环查
    keys()  values()  items()
    print(list(dict.keys()))
        for k in dict.keys():
            print(k)

        for v in dict.values():
            print(v)

        for d in dict.items():
            print(list(d))    默认是items是生成key value元祖

分别赋值:
    必须是一一对应。 不能多 不能少
    a,b =1,2
    a,b,c = ["alex","wusit","ritian"]
    有到比较坑的：
    a = 1
    b = 5
    a,b =b,a

    for k v in dict.items():
        print(k,v)

公共方法：
    len(dict)     键值对的数量

    dic.fromkeys={["name","age"],None}

2.7 set

集合
    无序的  不重复的数据类型  他里面的元素必须是可哈希的， 但是集合本身是不可哈希的
    1 关系测试 交集，并级，子级，差级，去重

set1 = {1,"alex","jack","tom",(1,2,3)}
# ss = [1,1,2,2,3,4,5,6,7,7]
# set2 = list(set(ss))
# print(set2)
#

增
    add
        set1.add("666")
        print(set1)
    update 迭代增加
        set1.update("jack")
        print(set1)

删
    remove  按照元素去删
        set1.remove("jack")
    pop  随机删

    del 从内存删除

关系测试

交集 &
print(set1 & set2)

并集 |
print(set1 | set2)
print(set1.union(set2))

差集 -
print(set1 - set2 )  set1 有的 set2中没有。也就是set1独有的
difference

反交集 ^
print(set1 ^ set2)   就是set1 与set2都有的其他的

子集 <
print(set1 < set2)     set1 是 set2 的子集

父级 >
print( set2 > set1)  set2 是 set1的父级

frozenset:  把集合变成一个冻集合
s = frozenset({1,2,3,4,5})  作为字典的键key来使用 就是不可变类型

3 数据类型补充

ll = ["alex","wustr","taibai","brray","老男孩"]

del ll[1::2]
print(ll)

for i in ll:
    if ll.index(i) %2 ==1:
        del ll[ll.index(i)]
print(ll)

# range 数字列表范围
###########################   大坑  ############################
for i in range(len(ll)):
    if i % 2 ==1:
        del ll[i]
print(ll)
在循环一个列表时，不要对列表进行删除的动作（改变列表元素的个数）
 两种方法:  方法一 ：
s1 = []
for i in range(len(ll)):
    if i % 2 ==0:
        s1.append(ll[i])
print(s1)

 方法二 ：
for i in range(len(ll)-1,-1,-1):
    # print(i)
    if i%2==1:
        del ll[i]
print(ll)

###############  字典的大坑 ################
 在循环字典的时候，不要改变字典的大小，或添加删除等操作。
否则会改变列表的元素，导致循环次数出现问题。
dic = {'k1':'v1','k2':'v2','k3':'v3',4:666}
错误：
for k,v in dic.items():
     if "k" in k:
       del dic[k]
print(dic)
错误：
for i in dic:
    # print(i)
    if "k" in i:
        del dic[i]
print(dic)
##  正确方法:
ll = []
for i in dic:
    if "k" in i:
        ll.append(dic[i])
print(ll)

####################  元祖问题 ###################3
如果 元祖里面只有一个元素 并且没有逗号隔开，那么他的数据类型与该元素一致
tul = (1)
print(tul,type(tul))    int类型
tu2 = ("alex")
print(tu2,type(tu2))    str类型

4 编码

注意 python3 版本    python2还有些区别

python3版本
    1 不同编码之间的 二进制是不能互相识别的。他们使用的不同的编码本。
    2 python3 str 内部编码方式（内存）为unicode
        但是，对于文件的存储，和传输不能用unicode. 占用存储空间大
        所以要用另一个bytes数据类型
        str的方法  bytes都有
    3 bytes型：内部编码方式（内存) 为非unicode
        对于英文；
        表现方式是：
                 str:
                    s ="hello world"
                    print(s,type(s))
                    是unicode 格式

                bytes:
                    s1 = b"hello world"
                    print(s1,type(s1))
                    非unicode 格式

        对于中文来说：
        表现方式：
            str:
              s = "中国"
              print(s,type(s))
            bytes:
              s1 = b"\xe4"
              print(s1,type(s1))

        转换：
            1 编码
                s = "laonanhai"
                s2 = s.encode("utf-8")    将str转换为bytes类e型 encode 编码
                print(s2)

                s = "中国"
                s2 = s.encode("utf-8")            将str转换为bytes类e型 encode 编码
                s3 = s.encode("gbk")
                print(s2)
                print(s3)
            2 解码
                s = "中国"
                s2 = s.encode("utf-8")
                ss = s2.decode("utf-8")         将bytes转换为str类型  decode 解码
                print(ss)

练习题

购物车功能要求：

要求用户输入总资产,列如：2000

显示商品列表，让用户根据序号选择商品，加入购物车

购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
goods = [　 {"name": "电脑", "price": 1999},
　　　　　　{"name": "鼠标", "price": 10},
　　　　　　{"name": "游艇", "price": 20},
　　　　　　{"name": "美女", "price": 998},
]
money = input()
shopping_car = [{name:；电脑，count：3}]
1,展示商品
1， 电脑 1999
2， 鼠标 10
.....
1,输入的是全部数字
2，判断，范围。
购买成功，打印购买的商品列表
'''