day02 基本数据类型

目录

• 今日内容
• 编码
• 基本数据类型
  • 列表list
    • 列表的增 删 改 查
    • 深浅拷贝
  • 循环 for循环
  • 字符串（str）
  • 元组（tuple）
  • 字典（dict）
  • 补充
• 练习

今日内容

# 1.拾遗
    # pass语句
    # 格式化输出
        # %s
        # '其他内容%s其他%s内容'%(变量,变量2)
    # 运算符
        # 算数运算符 + - * / % //
        # 比较运算符 > < >= <= == !=
        # 赋值运算符（新）
            # =
            # +=
            # -=
            # *=
            # /=
            # %=
        # 逻辑运算符（新）
            # and 与
            # or  或
            # not 非
            # 优先级 括号>not>and>or
        # 身份运算符（新） :判断的是两个变量的内存地址
            # is
            # is not
            # 如果两个变量的内存地址相等，值一定相等
# 2.编码
    # 编码的种类 ： ascii、gbk、unicode、utf8
    # UNICODE --> UTF8 'ABC'.encode('utf-8')
    # UNICODE <-- UTF8 b'xe6xe8xe7'.decode('utf-8')
# 3.基本数据类型
    # bool int float
    # list
        # 索引
            # 正数 0~n
            # 倒数 -1~-m
        # 切片的特点：有步长，步长可以省略，顾头不顾尾
            # [start:end:step]
            # [::] [:]
            # [:3]
            # [:3:1] [:3:2] [4:9]
            # [::-1] 完全反转列表
        # 增 append 向末尾添加值
        # 删 lst.remove('值') lst.pop()删掉列表的最后一个值
        #    lst.clear()    del lst[8]
        # 修改 lst[索引] = 新的值
        # 值的引用
        # 浅拷贝
    # 通用的操作
        # in /not in
        # len(lst) 查看列表的长度
        # 获取列表中的每一个元素
            # for  break continue else
                # 都是循环一个固定的数据类型 —— 迭代的过程(没有死循环)
            # while break continue else（有死循环）
                # 根据一个条件进行循环
    # str
        # 索引
        # 切片
        # 循环
        # 大小写的转换 upper
        # 分割和合并 split join
        # 替换 replace
        # 去掉边界上的内容 strip()   strip('<>')
        # 开始和结尾 startswith  endswith
        # 字符串的组成 isdigit
    # tuple 元组（元素1,元素2）
        # 不可变的序列
        # 可以切片
        # 可以循环
        # 可以使用索引查看
    # dict 字典 {'k1':'v1',123:'v2',(1,2):['alex','83']}
        # key有要求，不能是列表字典也不能重复
        # 可以循环，并且循环取到的key
        # 增
            # d['不存在的key'] = 值
        # 删
            # d.pop('key')
            # del d['key']
        # 改
            # d['存在的key'] = 新的值
        # 查
            # d['存在的key']
            # d.get('不知道存不存在的key')
    # range
        # print(range(1,100))
        # for i in range(0,101,2):
        #     print(i)

编码

# 编码的种类 ： ascii、gbk、unicode、utf8
# UNICODE --> UTF8 'ABC'.encode('utf-8')
# UNICODE <-- UTF8 b'xe6xe8xe7'.decode('utf-8')

• 进制

# n进制   一位最多能表示0~(n-1)
# 0101010101111001

# print(100)
# print(bin(100)) # 十进制转二进制
# print(oct(100)) # 十进制转八进制
# print(hex(100)) # 十进制转十六进制

# print('hello world')
# 内存 ：二进制
# 硬盘山

# 二进制         -->    23533334030232120
# 1010101010 #逢二进一
# print(bin(5))
# 0001011100000101
# 用固的长度
# A 65
#
# a 97
# {
# }
# [
# 0-255
# 8位2进制
# 11111111 -->255
# 00000000 -->0

# 0、1 1位  1bit   比特、位
# 8位 8bit  1byte  字节
# 1024字节  1kb
# 1024kb    1mb
# 1024mb    1gb
# 1024gb    1tb

• ASCII码

# ascii码
# 中国 gb2312
# 万国码 unicode
# 中国 gbk
# utf8 可变长的编码

# 4个字节 4个字节表示一个文字
# 4*8 = 32位
# print(2 **32)
# 00000000 01010101 01010010 01010111
# 01110000 01010101 01010010 01010111
# 00000000 00000000 00000000 00001100

• utf-8

# utf8 可变长的编码
    # 英文字母 8位  1byte
    # 欧洲文字 16位 2bytes
    # 中国文字 24位 3bytes

• 编码使用与转换

# 编码使用在哪儿的？
    # unicode ：程序的内存里的
        # print('你好，中国')
    # utf-8：存在文件里或者在网络上传输的时候
        # unicode ———> utf8

# 编码的转换
# s = '你好，中国'
# print(s.encode('utf-8'))  # unicode-->utf-8
# b = b'xe4xbdxa0xe5xa5xbdxefxbcx8cxe4xb8xadxe5x9bxbd'
# print(b.decode('utf-8'))

# s = '你好，中国'
# print(s.encode('GBK'))  # unicode-->utf-8
# b = b'xc4xe3xbaxc3xa3xacxd6xd0xb9xfa'
# print(b.decode('gbk'))

基本数据类型

列表list

• 数据结构(新)--->列表list

lst = ['张晗','胡日查','老王','周老板','小强'] ##列表没有长度大小限制，只要内存存的下
print(lst) #lst指向整个列表

• 索引（正向索引/反向索引）

索引-下标  通过索引(下标)取值(所在值的目录)
print(lst[0]) #计算机从0开始计数
print(lst[1])
print(lst[2])
print(lst[3])
print(lst[4])
print(lst[5]) # 报错 IndexError: list index out of range #索引不在
print(lst[-1]) #反向索引，最后一个
print(lst[-2]) #倒数第二个
print(lst[-3])
print(lst[-4])
print(lst[-5])

• 切片(顾头不顾尾)

print(lst[:]) #切所有
print(lst[:2]) #从0开始切切到2
print(lst[2:]) #从2往后切
print(lst[1:3]) #从1开始但不到3
print(lst[-3:-1:1])   # start:end:step（开始:结束:步长）
print(lst[-3:-1:1])
print(lst[-1:-3:-1])
print(lst[::-1]) #反转列表
print(lst[::2]) #从头切到尾隔一个取一个
print(lst[1::3]) #从头到尾隔两个取一个

lst = ['张晗','胡日查','老王','周老板','小强']
lst2 = lst[:]
print(lst == lst2) #值相同，返回True
print(id(lst)) #id不同
print(id(lst2)) #id不同
列表的拷贝
lst3 = lst.copy() #列表拷贝新的列表，新列表与原列表值相同，但是内存地址不同
print(lst)
print(lst2)
print(lst3) 

列表的增 删 改 查

• 增

append
insert
lst = [1,2,3,4,5,6,7,8,9,'alex','老王',True,12.334] #列表什么都可以放入
l = lst.append('贡金敏') #l没有
print(lst) #lst列表末尾增加了一个值
lst.insert(0,'胡日查') #在开头增加了一个值
print(lst)
lst.insert(10,'周老板') #一般不用insert,一般用append
print(lst)

• 删

lst.remove(8) #删除某个值
print(lst)

n = lst.pop() #删除最后一个，一般只用这个
print(n) #可以拿到删除的值
print(lst)
n = lst.pop() #可以接收结果
n = lst.pop(0) #删除开头的第一个值，可以删除指定位置的值（但是一般不用这种形式）
print(n)
print(lst)
lst.clear() #清空列表，比较少用
print(lst)
del lst[8] #删掉列表索引为8的值，比较少用
print(lst)

• 改

lst = [1,2,3,4,5,6,7,8,9,'alex','老王',True,12.334]
a = 'alexsb'
lst[9] = a
print(lst) #根据索引位置，重新赋值
lst[8] = 7+5

深浅拷贝

• 浅拷贝

l = ['alex',123,True,['王剑', '6666', '20'],['周老板', '123456', '50']]
l2 = l[:] #浅拷贝
l3 = l.copy() #浅拷贝

l2.append('hello,world')
print(l)
print(l2) #只有l2增加了
print(l3)

l2[3].append('hello kitty')
print(l) #都有hello Kitty了
print(l2) #因为存储的都是地址
print(l3)

# 浅拷贝并不是在内存中生成完全隔离的三个数据，而是只有第一层互相隔离开了，剩下的其他拷贝的内存地址发生了变化，所有的列表都共享这个变化，只拷贝一层就是浅拷贝

• 深拷贝

import copy
l2 = copy.deepcopy(l)
l2[3].append('hello kitty')
print(l)
print(l2) # 不推荐深拷贝，浪费内存，因为Python所有变量都指向内存地址

lst = [1,2,3]
l = ['alex',123,True] #列表里还包含列表
l2 = ['alex',123,True] 
l[2] = False #修改了l[2]，但会不影响l2
print(l)
print(l2)

lst = [1,2,3]
l = ['alex',123,True,lst] #列表里还包含列表
l2 = ['alex',123,True,lst]
lst.append(4) #如果lst增加了值
print(l) #也会改变
print(l2) #会改变

• in / not in 判断值

l = ['wusir','alex','alex']
print(l.index('alex'))
print('alex' in l)
print('alex2' in l)
print('alex2' not in l)
print('alex' not in l)

• 排序

l = [3,2,5,7,1,9,10]
l.sort()
print(l)

• 计算列表长度

l = [3,2,5,7,1,9,10,11,15,17]
print(len(l))   # length
n = 0
while n<len(l): #获取列表的每一个元素
    print(l[n]) #可以获取最后一个值n<1
    n += 1

循环 for循环

l = [3,2,5,7,1,9,10,11,15,17]
for n in l:
    print(n)

while循环和for循环的区别
while循环是根据条件来的 结束循环的次数是不固定的
for循环循环的次数永远等于你循环的那个列表/其他数据类型的长度

for i in l:
    if i ==10:
        break #退出机制
    print(i)

for i in l:   # 迭代
    if i ==10:
        continue
    print(i)

字符串（str）

s = 'alex今天去洗脚城遇到了wusir'
# 字符串 就是一堆字符组成一串,python没有字符的概念
# 字符串拥有索引的
s = 'alex今天去洗脚城遇到了wusir'
print(s[0])
print(s[-1])
print(s[10])
# 切片
print(s[0:4])
print(s[:4])
print(s[::-1])

• 字符串的循环

for char in s:
    print(char) #迭代每一个字符并打印

• 修改大小写

s = 'q'
print(s.upper()) #一般用upper

s2 = 'Q'
print(s2.lower())

# 让用户录入全班同学的名字
l = []
while True:
    name = input('同学的名字 :')
    if name.upper() == 'Q':
        break
    l.append(name)
    print('已添加%s同学'%name)
print(l)

• 切割和合并

s = 'alex|alex3714|83'
l = s.split('|')
print(l)


s2 = '|'.join(['alex', 'alex3714', '83']) #合并
print(s2)

s = ['alex', 'alex3714', '83']
l = ','.join(s)
print(l)

• 替换 replace

s = 'wusir和wusir是一对儿好基友'
s1 = s.replace('wusir','老王')
print(s)
print(s1)
s2 = s.replace('wusir','老王',1) #从头开始，只替换1个
print(s)
print(s2)

• 去掉边界上的内容 strip

 s1 = '   wa    haha   '
 print(s1.strip())

 usr = input('user :').strip() #去掉输入的空格
 pwd = input('passwd :').strip()
 if usr == 'alex' and pwd == 'alex3714':
     print('登陆成功')
 else:
     print('登录失败')

 s2 = '<娃哈哈>'
 print(s2.strip('>')) #去掉特殊符号
 print(s2.strip('<'))
 print(s2.strip('<>')) #去掉两边的符号

 s3 = 'hello,apple'
 s4 = s3.strip('hello') #按照字符一个个去掉
 print(s4)

• 判断字符串的开始和结尾

s0 = '2019-9-10 17:02:22'
s1 = '2019-9-10 17:02:23'
s2 = '2019-9-10 18:02:22'
print(s0.startswith('2019-9-10 17:02')) #判断已什么什么开始
print(s1.startswith('2019-9-10 17:02'))
print(s2.startswith('2019-9-10 17:02'))

l = [s0,s1,s2]
for s in l:
    if s.startswith('2019-9-10 17'):
        print(s)

a = 'eating'
b = 'sleeping'
c = 'worked'
l = [a,b,c]
for word in l:
    if word.endswith('ing'):  #判断以什么什么结尾
        print(word)

• 字符串的组成

num = input('红球的号码 :')
print(type(num))
if num.isdigit():
    num_int = int(num)
    print(type(num_int))
else:
    print('请输入数字来确保程序正常运行')

• 判断这个字符串是不是完全由数字组成

s1 = '12345'
s2 = 'abc123'
print(s1.isdigit()) #判断结果 True
print(s2.isdigit()) #判断结果 False

s1 = '12345'
s2 = 'abc你好壹仟'
print(s1.isalpha()) #是不是由语言中最简单字符组成，结果False
print(s2.isalpha())#结果 True（不太用这个）


s = '菠萝蜜苹果香蕉'
print('香蕉' in s)
print('菠萝蜜' in s)
print('菠萝' in s)

l = ['菠萝蜜','苹果','香蕉']
print('香蕉' in l)
print('菠萝蜜' in l)
print('菠萝' in l)

s = 'alex菠萝蜜苹果香蕉'
print(len(s))

• 修改和赋值上的问题

a = 'alex'
b = a
a = 'wusir'
print(b)

元组（tuple）

days = ('星期一','星期二','星期三','星期四'
        '星期五','星期六','星期天') #元素不能变更
print(days[0]) #索引
print(days[0:3]) #切片，结果也是元组
for day in days:
    print(day)

day[6] = '周日' #会报错，不支持修改

a = (1,)
print(a)

• 数据类型之间的转换

lst = [1,2,3,4]
tup = tuple(lst) #列表转为元组
print(type(tup))
print(tup)

lst2 = list(tup) #元组转为列表
print(tup)
print(lst2)

字典（dict）

d = {
 'alex':'alex3714',
 'wusir':'666',
  'alex10000':'222222'
 }
print(d['alex'])
print(d['alex10000'])

# 登录
username = input('username :')
password = input('password :')
if username in d and d[username] == password:
    print('登录成功')
else:
    print('登录失败')

d = {
 'alex':'alex3714',
 'wusir':'666',
  'alex10000':'222222'
 }
 
 username = 'alex'
d[username]  # d['alex']
'alex':'alex3714'  k-v
k-v
# 永远是通过key找value

• 增删改查

# 增
d['老王'] = '999' #key不存在，就是增加
print(d)
d['老王'] = '感冒灵' #key已存在就修改
print(d)

# 删
d.pop('alex')
print(d)

del d['alex']
print(d)

# 改
d['wusir'] = '777'

# 查
print(d['wusir'])
print(d)

• 要求

# 字典的key是有要求的
 # 不能重复写两个key
 # key必须是可hash的：
    # 可以通过一个哈希算法计算出一个变量的哈希值
    # 不能做字典的key ：list dict set
    
d = {'alex':84,'alex':73,123:['a','b'],(1,2,3):{'k':'v'}}
d['alex'] = 125
print(d)

• 字典的循环

for i in d:
  print(i,d[i])

d = {'k1':'v1'}
print('k1' in d)
print('v1' in d)
# d['k2']  # KeyError: 'k2' #不存在的key
print(d.get('k1')) #存在返回值
print(d.get('k2')) #不存在返回None

补充

# bool值
# 数字 0 False
    # 非0 True
# 字符串 '' False
    # 非空 True
# [] tuple() {} --> False
# None --> False

lst = []
if lst:
    print(lst)
else:
    print('列表为空')

练习

1. 写一个列表，描述一个人(lst.append)

写一个列表，描述一个人
[姓名,密码,年龄]
l2 = []
name = input('name :')
l2.append(name)
pwd = input('password :')
l2.append(pwd)
age = input('age :')
l2.append(age)
print(l2)

l = ['王剑', '6666', '20']
l2 = ['周老板', '123456', '50']
lst = []
lst.append(l) #可以增加一个列表类型
lst.append(l2)
print(lst)

修改王剑的年龄 --> 22
lwang = lst[0]
lwang[2] = 22
print(lwang)
print(lst)

2. 练习描述(in/not in)

# 循环5次
# 输入用户的名字，如果名字之前存在了，就提示已经存在
# 如果这个名字之前未存在，把这个名字添加到列表中
# 最后打印列表

n = 0
l = []
while n<5:
    name = input('username :')
    if name in l:
        print('您输入的用户名%s已经存在'%name)
    else:
        l.append(name)
        n += 1    # 只有当用户输入5个不重复的用户名程序才结束
print(l)

n = 0
l = []
while n<5:
    name = input('username :')
    if name in l:
        print('您输入的用户名%s已经存在'%name)
    else:
        l.append(name)
    n += 1    # 只要用户输入5个用户名，不管重复与否程序都结束
print(l)

3. 练习描述（for循环）

# 让用户输入用户名和密码
# 只要用户名和密码对上了l中的值，显示登陆成功
# 否则，显示登陆失败

l = [['alex','222'],['wusir','666'],['周老板','123456']]
username = input('username :')   # wusir
password = input('password :')   # 123
login = False
for item in l:   # ['alex','222']  ['wusir','666']  ['周老板','123456']
    if username == item[0] and password == item[1]:
        print('登陆成功')
        login = True #状态正常结束
        break
if login == False: #用户输入后先判断login的状态
    print('登陆失败')

for i in [1,2,3,4]:
    print(i)
else:
    print('循环完啦')

for i in [1,2,3,4]:
    print(i)    # i=1  i=2  i=3  i=4
    if i == 3:
        break
else:
    print('循环完啦')

username = input('username :')   # wusir
password = input('password :')   # 123
for item in l:   # ['alex','222']  ['wusir','666']  ['周老板','123456']
    if username == item[0] and password == item[1]:
        print('登陆成功')
        break
else:  # 当for循环执行结束，并且在执行过程中没有被break，执行else中的代码
    print('登陆失败')

i = 0
while i<5:
    print(i)
    i = i+1
    if i == 3:
        break
else:
    print('执行完拉')

4. 练习描述（元组）

tup = (1,2,3,4)
lst = list(tup)
print(lst)
lst.append(5)
print(lst)
t =tuple(lst)
print(t)
print(tup)
tup = t
print(tup) #重新赋值，不常用