python数据类型定义为_<一>Python 数据类型

变量、字符编码

1:声明变量：

#_*_coding:utf-8_*_

#__author__:"shikai"

name="shikai"

#变量名：name 变量的值：shikai

定义变量规则：

✪变量名只能是 字母、数字或下划线的任意组合

✪变量名的第一个字符不能是数字

✪关键字不能声明为变量名

['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

2:字符编码

1K=1000B    1B=8bit

UTF-8编码：一个英文字符等于一个字节，一个中文(含繁体)等于三个字节。中文标点占三个字节，英文标点占一个字节

Unicode编码：一个英文等于两个字节，一个中文(含繁体)等于两个字节。中文标点占两个字节，英文标点占两个字节

设置默认编码格式，告诉Python解释器

注：ascii码无法表示中文

#!_*_coding:utf-8_*_

#__author__:"shikai"

name="shikai"

注释：

当行注视：# 被注释内容

多行注释：""" 被注释内容 """

用户输入：

#!_*_coding:utf-8_*_

#__author__:"shikai"

#用户输入

name=input("your name:")

print(name)

getpass模块让输入密码不可见：(注：在Windows下的CMD才不会显示密码)

#!_*_coding:utf-8_*_

#__author__:"shikai"

import getpass

# 将用户输入的内容赋值给 name 变量

pwd = getpass.getpass("pwd:")

# 打印输入的内容

print(pwd)

数据类型

1:数字

int(整型)：

如：1,2,3

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

float(浮点型)：

如：3.14,5.2

浮点数用来处理实数，即带有小数的数字。

long(长整型)　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

complex(复数)

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

2：布尔值：True 或者False

3：字符串

每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，字符串拼接的+号每出现一次就会在内从中重新开辟一块空间。

运算：

注：取前后索引值是顾前不顾后

#!_*_coding:utf-8_*_

#__author__:"shikai"

a,b="shikai","AAA"

print(a+b) #结果：shikaiAAA

print(a*2) #结果：shikaishikai

print(a[1:4]) #结果：hik

print("s" in a) #结果：True

print("AAA" not in a) #结果：True

字符串的格式化：

print("{} is student,his num is {}".format("shikai",7))

字符串内建函数：

a,b="shikai","AAA"

#:①：find() 返回被查字符串的索引，如果没在就返回：-1

print(a.find("i")) #结果：2

#②：index() 和find一样单如果被查值不在字符串里就报错

print(a.index("i")) #结果：2

#③：capitalize() 把字符串的第一个字符大写

print(a.capitalize()) #结果：Shikai

#④：count 统计出现次数

print(a.count("i")) #结果：2

#⑤：replace (a，b) 把a替换成b

print(a.replace(a,b)) #结果：AAA

#⑥：split 按照字符串原则分割成一个列表，后面数字是只分隔多少个

print(a.split("i")) #结果：['sh', 'ka', '']

print(a.split("i",1)) #结果：['sh', 'kai']

#⑦：string.swapcase() 翻转 string 中的大小写

#⑧：string.upper() 转换 string 中的小写字母为大写

#⑨：join 连接2个字符串

str = "-"

seq = ("a", "b", "c") # 字符串序列

print(str.join( seq )) #结果：a-b-c

4：列表

列表脚本操作：

列表函数：

增：append、extend、insert、+、*

list1=[1,2,"shikai"]

list2=["AAA","BBB","CCC"]

#①：list.append(obj) 在列表末尾添加新的对象

list1.append("AAA")

print(list1) #结果：[1, 2, 'shikai', 'AAA']

#②：把list2列表里的值添加到list1

list1.extend(list2) #结果：[1, 2, 'shikai', 'AAA', 'AAA', 'BBB', 'CCC']

#③：list.insert(index, obj) 在index索引位插入值

list1.insert(1,"eric") #结果：[1, 'eric', 2, 'shikai', 'AAA']

#④a=list1+list2 #结果：[1, 'eric', 2, 'shikai', 'AAA', 'AAA', 'BBB', 'CCC']

#⑤b=list1*2 #结果：[1, 'eric', 2, 'shikai', 'AAA', 1, 'eric', 2, 'shikai', 'AAA']

删：del、remove、pop

#_*_coding:utf-8_*_

#__author__:"shikai"

list1=[1,2,"shikai"]

list2=["AAA","BBB","CCC"]

#①：del 直接删除

del list1

#②：remove 指定删除某个元素

list1.remove("shikai") #结果：[1, 2]

#③：pop() 函数用于移除列表中的一个元素(默认最后一个元素)

list1.pop() #结果：[1, 2]

list1.pop(1) #移除索引位置，结果：[1, 'shikai']

查：count、按索引位、index、in

list2=["AAA","BBB","CCC",1,"AAA",3,"BBB",1]

#①：count 某个元素出现的次数

print(list2.count("AAA")) #结果：2

#②：按索引位选取

a=[1,2,3,4,5,6]

print(a[1:4]) #结果：[2, 3, 4]

print(a[2:]) #结果：[3, 4, 5, 6]

print(a[-2]) #倒数第二个元素：5

print(a[::2]) #隔2隔位置去一个值：[3,6]

#③ index 查询列表中某元素的索引位

print(list1.index("shikai")) #结果：2

#④判断谋元素是否存在

print(2 in [3,2,1]) #结果：True

#④：

改：list、reverse、sort

#①将元祖修改为列表

a=(1,"shikai",3,4)

b=list(a)

print(b) #结果：[1, 'shikai', 3, 4]

#②直接赋值修改 list1[1]="AAA"

#③ reverse 翻转列表

list1=[1,2,"shikai"]

list1.reverse()

print(list1) # 结果：['shikai', 'AAA', 1]

#④：sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序(默认)。

a=[3,8,1,2]

a.sort(reverse=True) #降序排列

print(a)

5：元组

元祖不能修改，只有count和index

#_*_coding:utf-8_*_

#__author__:"shikai"

name=("shikai","AAA","BBB","AAA")

print(name.count("AAA")) #结果：2

print(name.index("AAA")) #结果：1

6：字典

字典一种key - value 的数据类型，

字典的特性：

dict是无序的

key必须是唯一的,

增：dict1["school"]="CDUT"

#_*_coding:utf-8_*_

#__author__:"shikai"

#①直接增加

dict1={'name':'shikai','age':8,'num':7}

dict1["school"]="CDUT"

print(dict1) #结果：{'name': 'shikai', 'age': 8, 'num': 7, 'school': 'CDUT'}

删：pop、popitem、del、clear

dict1={'name':'shikai','age':8,'num':7}

#①：pop 指定删除

dict1.pop("num") #结果：{'name': 'shikai', 'age': 8}

#②del 删除

del dict1["age"] #结果：{'name': 'shikai', 'num': 7}

#③ popitem 方法随机返回并删除字典中的一对键和值。

dict1.popitem() #结果：{'name': 'shikai', 'age': 8}

#④：清除字典

dict1.clear() #结果：{}

查：in、get、keys、values、items

dict1={'name':'shikai','age':8,'num':7}

#① in

print("age" in dict1) #True

#②：get

print(dict1.get("name")) #结果：shikai

#③：print(dict1["name"]) # key不存在会报错，结果：shikai

#④：keys 返回所有keys

print(dict1.keys()) #结果：dict_keys(['name', 'age', 'num'])

#⑤：values 返回所有values

print(dict1.values()) #结果：print(dict1.values())

#⑥：items 以列表返回可遍历的(键, 值) 元组数组

print(dict1.items()) #结果：dict_items([('name', 'shikai'), ('age', 8), ('num', 7)])

#⑦：循环查询

for index,keys in enumerate(dict1.items()):

print(index,keys)

#结果

0 ('name', 'shikai')

1 ('age', 8)

2 ('num', 7)

改：update、直接赋值、copy

dict1={'name':'shikai','age':8,'num':7}

dict2={"school":"CDUT"}

dict1["name"]="AAA" #结果：{'name': 'AAA', 'age': 8, 'num': 7}

#②：update

dict1.update(dict2)

#结果：{'name': 'shikai', 'age': 8, 'num': 7, 'school': 'CDUT'}

#③：copy 浅copy

dict3=dict1.copy()

#结果dict3：{'name': 'shikai', 'age': 8, 'num': 7}

7：集合

集合是一个无序的，不重复的数据组合，关系测试，测试两组数据之前的交集、差集、并集等关系

s = set([3,5,9,10]) #创建一个数值集合

t = set("Hello") #创建一个唯一字符的集合

a = t | s # t 和 s的并集

b = t & s # t 和 s的交集

c = t – s # 求差集(项在t中，但不在s中)

d = t ^ s # 对称差集(项在t或s中，但不会同时出现在二者中)

基本操作：

t.add('x') # 添加一项

s.update([10,37,42]) # 在s中添加多项

使用remove()可以删除一项：

t.remove('H')

len(s)

set 的长度

x in s

测试 x 是否是 s 的成员

x not in s

测试 x 是否不是 s 的成员

s.issubset(t)

s <= t

测试是否 s 中的每一个元素都在 t 中

s.issuperset(t)

s >= t

测试是否 t 中的每一个元素都在 s 中

s.union(t)

s | t

返回一个新的 set 包含 s 和 t 中的每一个元素

s.intersection(t)

s & t

返回一个新的 set 包含 s 和 t 中的公共元素

s.difference(t)

s - t

返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.symmetric_difference(t)

s ^ t

返回一个新的 set 包含 s 和 t 中不重复的元素

s.copy()

返回 set “s”的一个浅复制