day1-6 字符串、列表、元组、字典、类型转换

day1

1、python历史。

宏观上：python2 与 python3 区别：
python2 源码不标准，混乱，重复代码太多，
python3 统一标准，去除重复代码。

2、python的环境。

编译型：一次性将所有程序编译成二进制文件。
缺点：开发效率低，不能跨平台。
优点：运行速度快。
：C，C++等等。

解释型：当程序执行时，一行一行的解释。
优点：开发效率高，可以跨平台。
缺点：运行速度慢。
:python ,php,等等。

3、break：跳出循环　　　　continue：到循环首

day2

1、编码

1bit 　　　　8bit = 1bytes
1byte 　　　　1024byte = 1KB
1KB 　　　　　1024kb = 1MB
1MB 　　　　　1024MB = 1GB
1GB 　　　　　1024GB = 1TB

　　最初是由美国人发明的ascii码，为密码本，后来发明了万国码“unicode”，可是代表汉子要占用4个字节，太大了；

　　所以发明了utf-8、utf-16、utf-32,一个字符24为，3字节

　　　　utf-8：最少用一个字节，8位表示一个英文；
　　　　　　　　欧洲16位，两个字节

　　　　　　　　亚洲24位，3个字节

中国人发明了gbk，一个中文16位去表示，2个字节

　　　　GBK：基于ascii研发的，只能支持中文和英文，不能喝utf-8直接转换

2、逻辑运算：And、or、not

优先级：( )>not>and>or
int ——> bool　　非零的转换成bool为True　　0转换为bool是False
bool ——> int　　True=1　　　　False=0
print(x or y)　　x 为 True时（非零为True），返回x　　否则返回y
print(x and y)　　x 为 True时　　　　　　　　返回y　　凑则返回x
print(1 or 2 and 3 or 1 > 2 and 5 )　　找找类似这样的规律　　“我感觉看到or就行”

day3

1、int

*.bit_length()　　　　//求数字转换为二进制最小长度

2、转换

 # bool True False

 # int ——> str

 i = 1

 s = str(i)

 # str ——> int  //只有数字可以转换

 s = ''

 i = int(s)

 # int ——> bool  //非零就是True，0位False

 i = 3

 b = bool(i)

 # bool ——> int     // True = 1， False = 0

 ''' ps：

 while True:

     pass

 while 1:    # 效率高

     pass

 '''

 # str ——> bool      //字符串位空 = False，非空为True

3、str

 # 索引和切片

 s = "ABCDESDASDEG"

 s1 = s[0]           # 取出第一个字母（A）

 s2 = s[2]           # 取出第三个字母（B）

 s3 = s[-1]          # 取出倒数第一位（G）

 s4 = s[-2]          # 取出倒数第二位（E）

 # 切片：顾首不顾尾

 s5 = s[0:3]         # 取出ABC

 s6 = s[0:-1]        # 取出第一个到倒数第二个（ABCDESDASDE）

 s7 = s[0:]          # 取出全部

 s8 = s[:]           # 取出全部

 # 跳着取[首:尾:步长]

 s9 = s[0:5:2]       # 第0个索引盗第5个索引，跳两个取（ACE）

 # 倒着取

 s10 = s[3::-1]      # 取 DCBA

 s11 = s[-1::-1]     # 逆序取全部

 s12 = s[::-1]       # 逆序取全部

 # 字符串操作

 s = 'alex.egon.wusir'

 s1 = s.title()              # 以字符和数字隔开的，其后的字母大写 返回（Alex Egon Wusir)

 s = 'alexWUsir'

 # 更改大小写

 s1 = s.capitalize()         # 首字母大写，其它大写的也变成小写

 s1 = s.upper()              # 全部变成大写

 s1 = s.lower()              # 全部小写

 s1 = s.swapcase()           # 大小写翻转

 # 居中和制表符

 s1 = s.center(20, "#")      # 设置一个20的长度，让字符串居中,默认用空格填充两边，可以使用其他符号，如"#"号

 s1 = s.expandtabs()         # 如果字符串中有“\t”则，在前边的封8进行补位

 # 字符串的判断

 s1 = s.startswith("al")     # 如果是以什么开头，是返回True

 s1 = s.startswith("e", 2)   # 从第二个字符到最后是不是以”e“开头，是返回True

 # 字符串的查找

 s1 = s.find("W")            # 查找字符串中是否有某个元素，有的话返回索引;没有返回-1

 s1 = s.find("U", )          # 从第二个开始进行查找，如果找到返回索引，找不到返回-1

 s1 = s.index("U")           # 寻找元素，找到返回索引，找不到报错

 # 删除空格

 s1 = s.strip()              # 去除前后的空格

 s1 = s.strip("@#$")         # 删除字符串中的前后@#$，不论顺序

 s1 = s.rstrip()             # 删除右侧

 s1 = s.lstrip()             # 删除左侧

 # 统计个数

 s1 = s.count("a")           # 计数字符串中有几个a

 # 分割 str ——> list

 s1 = s.split()              # 以空格分割为列表

 # 公共方法，字典、列表、元组都可以用的

 len(s)       # 测量总共有几个元素

 # 格式化输入

 s1 = "我叫{},今年{}，爱好{}，再说一次我叫{}".format('太白', 20, 'women', '太白')

 s1 = "我叫{0},今年{1}，爱好{2}，再说一次我叫{0}".format('太白', 20, 'women')

 # 替换

 s = '我的敬爱傻傻的啥大事傻傻卡号'

 s1 = s.replace("傻傻", '聪明')          # 替换全部

 s1 = s.replace("傻傻", '聪明', 1)       # 替换全部第一个

 # is系列

 s = "asdla131"

 s1 = s.isalnum()        # 是不是由字母或者数字组成

 s1 = s.isalpha()        # 是不是由字母组成

 s1 = s.isdigit()        # 是不是由数字组成

day4

1、list

 li = ["alex", [1, 2, 3], "wusir", "egon", "女神"]

 # l1 = li[0]

 # l2 = li[1]

 # 增

 # 1、增加：list.append        //默认增加到最后

 # li.append("日天")

 # li.append(2)

 # 持续添加，想退出按q or Q

 # while 1:

 #     name = input(">>>")

 #     if name.lower().strip() == "q":

 #         break

 #     else:

 #         li.append(name.strip())

 # 2、添加list.extent         //增加都最后

 # li.extend("123")

 # li.extend([1, 2, 3])

 # 3、插入：list.insert       //按照索引插入

 # li.insert(4, "大灰")

 # 删

 # 1、li.pop           //按照索引去删除,返回值为删除的元素，为空默认删除最后一个

 # print(li.pop())

 # 2、li.remove        //按照元素删除，元素必须存在，否则报错

 # li.remove("egon")

 # 3、li.clear         //删除所有元素

 # li.clear()

 # del              //删除列表,也可以切片删除

 # del li

 # del li[0:2]

 # 改

 # 1、直接改索引的值

 # li[0] = 'hello'

 # 2、切片改，选择切片范围，可以随便改，可大于范围，可小于范围

 # li[0:1] = "牛牛牛"

 # li[0:2] = [1, "asd", '你好', [1, 2]]

 # 查

 # 1、循环

 # for i in li:

 #     print(i)

 # 2、切片

 # print(li[0:3])

 # 公共方法

 # print(len(li))

 # print(li.count('egon'))

 # print(li.index("wusir"))

 li = [1, 64, 95, 55, 123]

 # li.sort()                   # 正向排序

 # li.sort(reverse=True)       # 倒序排序

 # li.reverse()                # 反转

 print(li)

list的增删改查

2、list嵌套

 li = ['taibao', '武藤兰', '苑昊', ['alex', 'egon', 89], 23]

 # print(li[1][1])     # 找到'藤'

 li[0] = li[0].capitalize()　　# ‘taibai’的首字母大写

 li[2] = li[2].replace("昊", '日天')

3、元祖

 # tu = (1, 2, 3, ['mrxuan', 'qwer', 'zxcvb'], 'egon')

 # tu[3][3] = tu[3][3].upper()

 # tu[3].append("Q")

 # print(tu)

4、字符串和列表的转换以及join的方法运用

 # 列表 --> str    join

 s = "-".join(["ni", 'hao', 'ya'])

 print(s)

 # 字符串转换为列表

 li = '我 你 他 哈 her new'.split()

 print(li)

5、range的用法

 # range

 for i in range(0, 10):

     print(i)

 for i in range(10, 0, -2):

     print(i)

day5

 # dict

 """

 数据类型划分：可变数据类型，不可变数据类型

 不可变数据类型：元组，bool，int，str     可哈希

 可变数据类型：list，dict，set           不可哈希

 dict key:必须是不可变数据类型  可哈希

 dict value：任意数据类型

 dict 优点：

         二分查找

         存储大量的关系数据

      特点：

         无序的

 """

 # dic = {

 #     'name': ['大猛', '小孟'],

 #     'py9': [{'num': , 'avg_age': }],

 #     True: ,

 #     (, , ): 'wuyiyi',

 #     : '二哥'

 # }

 # dic1 = {'age': , 'name': 'jin', 'sex': 'male'}

 # 增

 # 、 索引修改

 # dic1['high'] =       # 没有键值对，添加

 # dic1['age'] =         # 如果有建，则值覆盖

 # 、setdefault  键值对有的话，不做任何改变，没有则添加

 # dic1.setdefault('weight', )

 # 删

 # 、pop  返回key的value

 # print(dic1.pop('name'))

 #     如果没有则会报错； 可以在逗号后边添加一个参数，则不会报错

 # dic1.pop('aa')

 # dic1.pop('aa', None)        # None可以自定义写其他的，设置的参数将会成为pop的返回值

 # dic1.popitem()      # 随机删除一个键值，返回一个删除键值元组

 # del dic1['name']    # 删除

 # del dic1              # 删除字典

 # 改

 # dic1 = {'age': , 'name': 'jin', 'sex': 'male'}

 # dic = {'age': , 'name': 'alex', 'sex': 'male'}

 # dic1.update(dic)      # 将dic的字典更新到dic1，有的话覆盖，没有则增加

 # 查

 # print(dic1.keys())          # 所有的key

 # print(dic1.values())        # 所有的value

 # print(dic1.items())         # 所有字典的键值

     # for i in dic1:

     #     print(i)

     # for i in dic1.keys():

     #     print(i)

     # for i in dic1.values():

     #     print(i)

     # for k, v in dic1.items():

     #     print(k, v)

 # print(dic1['name'])

 # print(dic1['name1'])                  # 报错

 # print(dic1.get('name1'))                # 不报错

 # print(dic1.get('name1', '没有这个键'))    # 果果没有key则会返回后边的str

 # dic1.clear()          # 清空字典

 # print(dic1)

dict的增删改查

小知识汇总

# = 赋值　　　　== 比较　　　　　is 比较内存地址　　　　id(内容)：输出内存地址

# 数字，字符串　　定于小数据池，节省内存空间

# 数字的范围：-5 -- 256之间的数字会开辟一个内存空间

# 字符串：

不含有特殊字符
s * 20 还是同一个地址，s * 21 以后都是两个，s为一个字符

编码：
    ASCII
            A：00000010  8位  一个字节
    unicode
            A：00000000 00000001 00000010 00000100 32 位 四个字节
            中：00000000 00000001 00000010 00000100 32 位 四个字节
    utf-8
            A：  0010 0000 8位 1个字节
            中： 00000001 00000010 00000100 24 位 三个字节
    gbk
            A：  00000110  8位  一个字节
            中： 00000010 00000110 16位 两个字节

    1、个个编码之间的二进制，是不能互相识别的，会产生乱码。
    2、文件的储存、传输，不能使unicode（只能是ytf-8 utf-16 gbk gbk2313 ASCII）等

    python3：
        str 在内存中是用unicode编码。
            bytes类型：

        对于英文：
            str ：  表现形式：s = "alex"
                    编码方式：010101010  unicode
            bytes:  变现形式：s = b"alex"    b代表bytes类型
                    编码方式：000101010  utf-8 gbk.....
        对于中文：
            str ：  表现形式：s = "中国"
                    编码方式：010101010  unicode

                 s = 'alex'

                 s1 = b'alex'

                 print(s,type(s))

                 print(s1,type(s1))

            bytes:  变现形式：s = b"x\e91\e91\e91\e01\e21\e31\e32"    b代表bytes类型
                    编码方式：000101010  utf-8 gbk.....

 　　　　　　　　　 s = '中国'

                 s1 = b'中国'

                 print(s,type(s))

                 print(s1,type(s1))

 s1 = "alex"

 # encode 编码， str ——> bytes

 s2 = s1.encode('utf-8')

 s2 = s1.encode('gbk')

 s10 = "中国"

 s11 = s10.encode('utf-8')

 s11 = s10.encode('gbk')