python数据类型

登陆账户实例

Q：登陆三次，错误，自动锁定。再次登陆，依旧锁定。

（1）实现用户名的持久化；（写到文件或数据库中）

#Author:login

import json

''' 这部分初次进入时注册初始用户，当账户被锁定时，捕捉异常，不再出现此部分
_username = input("请注册账号：")
_password = input("请输入初始密码：")
user = {"user":_username,
        "passwd":_password
        }
#写字典

with open("passwd","w",encoding=("utf-8")) as f:
     json.dump(user,f)
     #将字典写入f文件
     f.close()
'''

try:
    with open("passwd","r",encoding=("utf-8")) as f:
        _user = json.load(f)
        #直接读文件
        _username = _user["user"]
        #从字典中取出元素
        _password = _user["passwd"]
    f.close()
#关闭文件
except json.decoder.JSONDecodeError:
    print("您的账号已经锁定，请联系管理员")

i = 0
while i < 3:
    username = input("username:")
    password = input("password:")
    if username == _username and password ==_password:
        print("logginning...")
        exit()
    else:
        if i == 2:
            with open("passwd","a",encoding=("utf-8")) as f:
                f.write("#")
                print("用户账号已锁定...")
        else:
            print("username or password error...")
            print("请再输入一次...")
    i += 1

---

数据类型

字符串

​ python的字串列表有2种取值顺序:

​ 从左到右索引默认0开始的，最大范围是字符串长度少1

​ 从右到左索引默认-1开始的，最大范围是字符串开头

​ 要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

​ 加号（+）是字符串连接运算符，星号（*）是重复操作。

​ Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并

​ 设置为步长为 2（间隔一个位置）来截取字符串：

​ [头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

a = “womendoushihaohaizi”

a[:5] ‘women’

a[5:] ‘doushihaohaizi’

a[5:10] ‘doush’

使用方法修改字符串的大小写

#Author:Anliu

name = "wo men ai shangluo"

print(name.title())

结果：Wo Men Ai Shangluo

注：name.title()中，name后面的（.）让Python对变量name执行的方法。

还有类似以下方法：

`#Author:Anliu`

name = "wo men ai shangluo"

print(name.title())

print(name.upper())

print(name.lower())

删除空白

#Author:Anliu

name = "\tpython\t"

print(name)

print(name.rstrip())

print(name.lstrip())

print(name.strip())

---

**列表 ** [ ] list

用[ ] 标识

查：（切片操作）

names = ["zhangsan","lisi","wanger","xx"] 

print(names[names.index("xx")]) 

names = ["zhangsan","lisi","wanger","xx","lisi"] 

print(names.count("lisi")) 

names = ["zhangsan","lisi","wanger","xx","lisi"] 

names.reverse() 

print(names) 

\#Author:Anliu 

names = ["zhangsan","lisi","wanger","xx","lisi"] 

names.sort() 

print(names) 

排序按照ACSII码的顺序。

\#Author:Anliu 

names = ["zhangsan","lisi",["wanger","xx"],"lisi"] 

for i in names: 

print(i) 

\#Author:Anliu 

names = ["zhangsan","lisi","wanger","xx","lisi"] 

names2 = ["dasfh","gsfs","","bcvbfj"] 

names.extend(names2) 

print(names) 

print(names2)

增：

1 在列表末尾添加元素 append

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

names.append("mazi")

print(names)

2 在列表中插入元素 insert

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

names.insert(0,"xxx")

print(names)

复制

#Author:Anliu

names = ["zhangsan","lisi","wanger","xx","lisi"]

names2 = names.copy()

print(names)

print(names2)

第二层不变：

`#Author:Anliu`

names = ["zhangsan","lisi","wanger","xx","lisi"]

names2 = names.copy()

names[2] = "王二"

print(names)

print(names2)

两层都变：

#Author:Anliu

names = ["zhangsan","lisi",["wanger","xx"],"lisi"]

names2 = names.copy()

names[2][0] = "王二"

print(names)

print(names2)

所以copy是一种“浅copy”

#Author:Anliu

import copynames = ["zhangsan","lisi",["wanger","xx"],"lisi"]

names2 = copy.deepcopy(names)

names[2][0] = "王二"

print(names)

print(names2)

这种方法两层都copy，是一种“深copy”

---

实际上“浅copy”有三种方式

#Author:Anliu

import copy

person=["name",['a',100]]

p1 = copy.copy(person)

p2 = person[:]

p3 = list(person)

print(p1,p2,p3)

“浅copy”在类似于共同账号的场景中有所应用，例如：

#Author:Anliu

import copyperson=["name",['saving',100]]

p1 = person[:]

p2 = person[:]

p1[0] = "anliu"

p2[0] = "dajiang"

p1[1][1] = 50

print(p1)

print(p2)

删：

1 使用del语句删除

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

del names[1]

print(names)

2 使用方法pop()删除元素

默认删除最后一个元素

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

names.pop()

print(names)

3 弹出列表中任何位置处的元素

如果你确定使用del语句还是pop()方法，就这样判断：如果你要存列表中删除一个元素，切不在以任何

方式使用它，就用del语句；如果你要在删除元素之后还能继续使用它，就用pop()方法。

#names = "zhangsan lisi wanger"

names = ["zhangsan","lisi","wanger"]

del_name = names.pop()

print("This a test_names of pop",del_name)

4 根据值删除元素

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

names.remove("lisi")

print(names)

改：

#Author:Anliu

names = ["zhangsan","lisi","wanger"]

names[0]="123"

print(names)

元祖（）

print(tuple) # 输出完整元组

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。 是一个不可变列表，不像列表一样能够修改元素。因此，元组没有修改操作行为，其他类似于列表。

字典 {} tinydict

一个键对应一个值

列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

#!/bin/evn python 
#-*- coding:utf-8 -*- 
#Author:Anliu 
dict = {} 
dict['one'] = "This is one" 
dict[2] = "This is two" 
tinydict = {'name': 'john', 'code': 6734, 'dept': 'sales'} 
print(dict['one']) # 输出键为'one' 的值 
print(dict[2]) # 输出键为 2 的值 
print(tinydict) # 输出完整的字典 
print(tinydict.keys()) # 输出所有键 
print(tinydict.values()) # 输出所有值
info = { 'hebei':"shijiazhuang", 
		'shanxi':"shangluo", 
		 'henan':"zhumadian"} 
print(info)  

增，删，改，查：**

#Author:Anliu 
info = { 'hebei':"shijiazhuang", 
	    'shanxi':"shangluo", 
	     'henan':"zhumadian"} 
print(info)
print(info["hebei"]) #访问字典值,该方法在键值不存在时报错 print(info.get("hebei")) #该方法在之不存在的时候，返回null 
print("hebei" in info) #判断键值是否存在于字典 
info["henan"] = "toujingai" #有则修改 
print(info)
info["hubei"] = "jinzhou" #无则添加 
print(info)#del info 删除字典 
info.pop("henan") #删除元素 
print(info)info.popitem() #随机删除print(info),不可以指定

嵌套：**

#Author:Anliu 
info = { 
	'1001':{'name':"zhangsan",'身高':"195",'体重':"180"}, 
	'1002':{'name':"lisi",'身高':"179",'体重':"250"}, 
	'1002':{'name':"wangwu",'身高':"180",'体重':"130"}}
print(info) 

集合 set();{}

集合是一个无序的，不重复的数据集合，可以使用大括号 { } 或者 set() 函数创建集合，注意：创

建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

​ 去重：一个列表变成集合，自动去重。

​ 关系测试：测试两组数据之间的交集，差集，并集等关系

关系测试

#求交集 
print(list_1.intersection(list_2)) 
\#求并集 
print(list_1.union(list_2)) 
\#求差集 
print(list_1.difference(list_2))#list1里面有，list2里面没有的 
\#求子集 
print(list_1.issubset(list_2)) 
\#求父集 
print(list_1.issuperset(list_2)) 
\#对称差集    即 两者的并集减去两者的交集
print(list_1.symmetric_difference(list_2)) 

#判断是否有交集，有则为不为真 
list_3 = set([5,6,9]) 
list_4 = set([4,7,9]) 
print(list_3.isdisjoint(list_4))

集合操作

#Author:Anliu #添加 
list_1 = set() 
list_1.add(999) 
print(list_1) 
list_1.update([666,777,555])  #变成列表
print(list_1) 

#删除 
list_1.remove(777) 
print(list_1) 
print(list_1.pop())   #删除最小的元素
print(list_1.discard(777)) 

#取长度 
print(len(list_1))

#判断元素是否在集合中 
print(666 in list_1) 
print(666 not in list_1)

序列化及反序列化

• 序列化:就是把不可传输的对象转换为可存储或可传输的过程

• 反序列化:就是把在磁盘,等介质中的数据转换为对象

  对于大多数应用程序来讲，dump()和load()函数的使用就是你使用pickle
  模块所需的全部了。
  dumps(object)和dump(object) :序列化
  loads(bytes)和load(bytes):反序列化

  import pickle
  dict1 = {"a": 1, "b": 2, "c": 3} 
  b = pickle.dumps(dict1)
  print(b,type(b)) # 1
  c = pickle.loads(b)
  print(c,type(c)) # 2
  
  输出结果:
  1:b'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02K\x02X\x01\x00\x00\x00cq\x03K\x03u.' <class 'bytes'>
  2:{'a': 1, 'b': 2, 'c': 3} <class 'dict'>
  

pickle 字符类型

​ pikle.dump()

​ pickle.loads()

json 字符串类型

​ json.dump()

​ json.loads()

for循环

#单个字母变大写
a = "python"
for i in a:
    b = i.upper()
    print(b)