三、Python基本数据类型

一、基本算术运算（获取的结果是值）

a1=10
a2=20#初始赋值
a3=a1+a2 #结果30
a4=a2-a1 #结果10
a5=a1*a2 #结果200
a6=a2/a1 #结果2
a7=a2**a1 #代表20的10次幂
a8=a2%a1 #取余
a9=a2//a1 #取商

　　取余、取商举例

'''
num=9%2
print(num)
#结果为1
'''
num=9//2
print(num)
#结果为4

二、比较运算（获取的结果是布尔值）

 例：利用true/false作比较（true/false用法在下面第六点）

v = 1 == 2
print(v)
#输出结果为false，此部分代码可用于后台登录认证部分书写

三、赋值运算（获取的结果是值）

 四、逻辑运算（获取的结果是布尔值）

 　　注意：优先级运算

　　（1）括号内优先

user="boy"
pwd="123"
v=user=="boy" and pwd=="123" and (user=="boy" and pwd=="111")
print(v)
#输出值为false

　　（2）从前到后算，前面是真，遇到or，则后面全为真；如果前面是假，遇到and，后面一定是假【不常用】

user="boy"
pwd="123"
v=user=="boy" and pwd=="123" or user=="boy" and pwd=="111"
print(v)
#输出值为true

五、成员运算（获取的结果是布尔值）

 　　例如：

name="abcde"
if "a" in name:
    print('true')
else:
    print('false')

name="abcd"
if "a" not in name:
    print('true')
else:
    print('false')

　　注意：在以上例题中，a、ab均在字符串中，但是ac不在字符串中。

六、 基本数据类型

###################————重点预知（必会）———— ####################

###################————重点预知（必会）———— ####################

1、数字

int（整型）——>Python3中数字类型均为整型

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

2、基本字符串功能（重点记join、split、find、strip、upper、lower 、replace）

（1）字符串转换

a="123"
print(type(a),a)
b=int(a)#字符串转换
print(type(b),b)
#结果为<class 'str'> 123 <class 'int'> 123

(2)进制转换

num="a"
v=int(num,base=16)#16进制转化为10进制，base等于2就是2进制转化为10进制
print(v)
#输出结果为10

（3）二进制位数表示

age=1
#1 01(二进制）
#2 10
#3 11
#4 110
#5 101
r=age.bit_length()
print(r)
#输出结果2，当age分别为1、2、3、4、5时，输出结果分别为1、2、2、3、3

2、布尔值

　　真或假

　　1 或 0

if true/while true 均为符合条件，即为死循环

name="abcde"
s= "a" in name
print(s)
#结果为True

3、字符串

"hello world"

（1）首字母大写转换text.capitalize()

text=("bob")
#首字母大写text.capitalize()
v=text.capitalize()
print(v)
#输出结果为Bob

（2）大写变小写（两种写法）text.casefold()

text=("boB")
#大写字母变小写
v=text.casefold()
print(v)
#输出结果bob

  text.lower()只能对应简单的变换，text.casefold()很对的未知关系也能变小写

text=("aileiR")
#大写字母变小写
v=text.lower()
print(v)
#输出结果alieir

（3）判断字符串是否都为大写或者小写，并进行相应转换

　　text.islower()#判断是否全为小写 　　text.lower()#小写转换

　　text.isupper()#判断是否全为大写　　text.upper()#大写转换

text="BBjdh"
v1=text.islower()#判断是否全为小写 
v2=text.lower()#小写转换
print(v1,v2)
v3=text.isupper()#判断是否全为大写
v4=text.upper()#大写转换
print(v3,v4)

　　运行结果：

（4）大小写全部转换 text.swapcase()

text="AAABBBhhhhh"
v=text.swapcase()
print(v)
#运行结果：aaabbbHHHHH

 （5）字符串居中，加空格功能 text.center(数字)

text="ababab"
#加20个空格
v=text.center(20)
print(v)

运行效果：

 （6）字符串居中，空格填充 text.center(数字,"填充符")

text="ababab"
v=text.center(20,"*")
print(v)

运行效果：

（7）字符串计数功能，去字符串中寻找子序列出现的个数  text.count("子序列元素")

text="ashdsdcgsdhn"
#计数字符串中有几个h
v=text.count("h")
print(v)
#输出结果为2

text="ashdsdcgsdhn"
#计数从第五个字母往后的字符串中有几个h
v=text.count("h",5)
print(v)
#输出结果为1

text="ashdsdcgsdhn"
#计数从第五个字母到第七个字母之间的字符串中有几个h
v=text.count("h",5,7)
print(v)
#输出结果为0

（8）判断字符串以什么结尾endswith("什么")、以什么开头 startswith("什么”）

text="dbhjdj"
#字符串以a结尾
v1=text.endswith("a")
#字符串以j结尾
v2=text.endswith("j")
#字符串以a开头
v3=text.startswith('a')
print(v1)#输出结果为False
print(v2)#输出结果为True
print(v3)#输出结果为False

（9）从前往后找，获取字符串的位置 find()

text="fnjjvncx"
v=text.find('j')
print(v)
#输出结果为2

text="fnjvncxj"
#获取起始位置
v=text.find("j",1,2)
print(v)
#输出结果为-1,代表没找到

（10）格式化，将字符串中的占位符替换成指定的值

　　a、带有名字（字符串）情况 test.format(name='Hzzhbest',sui=23)

test= 'i am {name},age {sui}'
print(test)#输出结果i am {name},age {sui}
v=test.format(name='Hzzhbest',sui=23)
print(v)#输出结果i am Hzzhbest,age 23

　　b、带有数字情况，从0开始，依次替换

test= 'i am {0},age {1}'
print(test)
v=test.format('Hzzhbest',23)
print(v)#输出结果i am Hzzhbest,age 23

　　c、字典类型格式化，传入的值必须为{"name":"HH","a":18}格式

test= 'i am {name},age {a}'
v1=test.format(name='Hzzhbest',a=23)
print(v1)#输出结果i am Hzzhbest,age 23
v2=test.format_map({"name":"HH","a":18})
print(v2)#输出结果i am HH,age 18

（11）判断输入字符串中是否只是数字或字母，不是运行结果为False,是为True  text.isalnum()

text="bdhfb8852_;?"
v=text.isalnum()
print(v)#输出结果为False

（12）判断输入字符串中是否只是字母或汉字，不是运行结果为False,是为True  text.isalpha()

text="hdghhdhhd"
v=text.isalpha()
print(v)#运行结果为True

（13）判断输入字符串中是否只是数字，不是运行结果为False,是为True； isdecimal()

text="455541855"
v1=text.isdecimal()#运行结果为true
v2=text.isdigit()#运行结果为false
print(v1,v2)

　　当数字类似于①、②等特殊符号时

text="①"
v1=text.isdecimal()#运行结果为False
v2=text.isdigit()#运行结果为True
print(v1,v2)

　　当数字为一、二、三这种类型时

text="四"
v1=text.isdecimal()#运行结果为False
v2=text.isdigit()#运行结果为False
v3=text.isnumeric()#运行结果为True
print(v1,v2,v3)

　　总结：isdecimal()仅仅支持数字；

　　　　    isdigit()包含特殊字符；
 　　　　   isnumeric()包含汉子。

（14）断句制表，expandtabs(20)，表示断句20

　　#\t 制表符

　　#\n 换行符

text="Mondey\tname\tage\n1\tlilei\t17\n2\tbub\t25\t"
#\t代表将字符填充到20，产生对齐效果，\n换行
v=text.expandtabs(20)
print(v)

运行结果：

（15）判断是否为标识符（标识符：字母、数字、下划线组成，数字不能开头）text.isidentifier()

text="_bdhjsas123"
v=text.isidentifier()
print(v)
#结果为true

text="123_njx"
v=text.isidentifier()
print(v)
#结果为false

（16）判断字符串是否存在不可显示的字符  text1.isprintable()

text1="djkcjd\nbchj"#其中\n不可显示
text2="jskhhhvb"
v1=text1.isprintable()
v2=text2.isprintable()
print(v1,v2)
#输出结果为False True

（17）判断输入的是否全部为空格  text1.isspace()

text1="cjds"
text2="ch  bsd"
text3="  "
v1=text1.isspace()#输出结果为False
v2=text2.isspace()#输出结果为False
v3=text3.isspace()#输出结果为True
print(v1,v2,v3)

（18）判断是否为标题（标题首字母都是大写） istitle()

text1="Process finished with exit code "
text2="Process Finished With Exit Code "
v1=text1.istitle()#输出结果为False
v2=text2.istitle()#输出结果为True
print(v1,v2)

（19）将普通字符串转化为标题

text="Process finished with exit code "
v=text.title()
print(v)
#输出结果为Process Finished With Exit Code

（20）将字符串的每一个元素按照指定分隔符进行拼接 " ".join(text)

text="好自为之"
print(text)
v=" ".join(text)
print(v)
s="__".join(text)
print(s)

　　运行结果：

（21）在字符串中左右填充指定分隔符

text="好自为之"
v1=text.ljust(20,"*")#左填充
v2=text.rjust(20,"*")#右填充
print(v1)
print(v2)

　　输出结果;

 （22）处理空格（可以移除空白，也可移除换行，如text="\ndjd "）

text="  djd   "
v1=text.lstrip()#处理左边空格
v2=text.rstrip()#处理右边空格
v3=text.strip()#处理两边空格
print(v1)
print(v2)
print(v3)

　　运行结果：

　　处理掉字符串的左边或者右边某个子元素

text="qwqwdjd"
v1=text.lstrip('q')#处理左边空格
v2=text.rstrip('d')#处理右边空格
print(v1)#运行结果wqwdjd
print(v2)#运行结果qwqwdj

（23）字符串替换 str.maketrans("原内容","替换内容”）

#创建一个对应关系
# text1="好自为之叭不"
# text2="123456"
text="好滋味自为知之叭叭不"
m=str.maketrans("好自为之叭不","123456")
v=text.translate(m)
print(v)

　　运行结果：

（24）按照某字符串进行分割

　　三份分割（从前到后，包含分割元素）partition

text1="好好学习天天向上"
v1=text1.partition("天")#按照天从前到后进行分割
v2=text1.rpartition("天")#按照天从后到前进行分割
print(v1)
print(v2)

　　运行结果：

 　　根据参数设定选择分割份数，没有参数将根据设定的字符串全部进行分割（不包含分割元素）

text1="好好天学习天天向上好的天下"
v1=text1.split("天")#按照天全部分割
v2=text1.split('天',2)#按照天从后到前进行分割,
print(v1,v2)
v3=text1.rsplit("天")
v4=text1.rsplit('天',2)
print(v3,v4)

　　运行结果：

　　若想设定是否包含分割元素，需要使用正则表达式（后面）

　　根据换行符分割（true包含换行符，false不包含换行符）

text="好好学习\n天天向上"
v1=text.splitlines()
v2=text.splitlines(True)
v3=text.splitlines(False)
print(v1)
print(v2)
print(v3)

　　运行结果：

（25）字符串替换 replace

text="bhffxsffjakkff"
v1=text.replace('ff','111')#全部替换
v2=text.replace('ff','222',2)#只替换两个
print(v1)
print(v2)

　　输出结果：

**********看源代码了解功能**********

3、特殊字符串功能（在大多数数据类型中都能用到）

（1）根据索引（下标）方式去获取字符串里某一个标识符

text="bab"
v1=text[0]#输出b
v2=text[1]#输出a
v3=text[2]#输出b
print(v1,v2,v3)

（2）根据索引（下标）方式去获取字符串里某范围内的标识符——切片

text="babbab"
v1=text[0:1]#输出b
v2=text[1:5]#输出abba
v3=text[0:-1]#-1代表最后一个位置，输出结果为babba
print(v1,v2,v3)

（3）获取字符串中有多少个字符组成

text="hjgfgsdsb"
v=len(text)
print(v)#输出结果为9

　　当字符串为列表是，len计算的为列表中“，”分割的有多少个元素

li=[11,2,2,"de","jf"]
v=len(li)
print(v)#输出结果为5

（5）使字符串一个一个输出

　　方法一：while循环

text="好自为之"
index=0#设置下标
while index < len(text):
    v=text[index]#根据下标取值
    print(v)
    index+=1
print("____END____")

　　输出结果：

 　　方法二：for循环

text="好自为之"
for tt in text:
    print(tt)

　　语法：

（7）将文字对应的索引（下标）打印出来

字符串常用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

查看某字符串功能，选中，Ctrl+shift+双击

4、列表

创建列表：

列表中的数字可以是数字、字符串、列表、布尔值......，列表可进行无限嵌套

name_list = ['alex', 'seven', 'eric']#通过list类创建的对象，名为name_list
#或
name_list ＝ list(['alex', 'seven', 'eric'])

基本操作：

• 索引

  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  v1=li[2]
  print(v1)#结果为345
  v2=li[3][1]
  print(v2)#结果为dh

• 切片

  #通过切片取值
  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  print(li[2:4])#结果为[345, ['chdsf', 'dh']]

• for循环、while循环

  #for、while循环
  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  for item in li:
      print(item)

  运行结果：

• 

• 列表可进行修改

  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  li[1]="HHH"#通过索引修改
  li[2:3]=[111,222]#通过切片修改
  print(li)#输出结果['asa', 'HHH', 111, 222, ['chdsf', 'dh'], 'gd', '哈哈哈']

• 列表可进行删除

  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  del li[3]
  print(li)#输出结果['asa', 123, 345, 'gd', '哈哈哈']

• in操作，包含

  li = ["asa",123,345,["chdsf","dh"],"gd","哈哈哈"]
  v1="as" in li
  v2="哈哈哈" in li
  print(v1,v2)#输出结果False True
  

• 字符串可以转化成列表形式，数字不可以转化成列表形式，转化过程中本身就是调用一个for循环

  text="bcdh"
  li=list(text)
  print(li)#输出结果['b', 'c', 'd', 'h']
  

• 列表转化成字符串时，只能自己写循环或者用“ ”.join拼接（全是字符串）

  li=["gd","h","ch"]
  for i in li:
      print(i)

• li=["gd","h","ch"]
  v="".join(li)
  print(v)#输出结果gdhch

  列表转化成字符串时，只能自己写循环（数字+字符串）

  s=""
  li=[123,"hFd",456]
  for i in li:
      s=s+str(i)
  print(s)

（1）在原值后面追加一个值 append

li=[12,3,2,13,342]
v=li.append(9)
print(li)#输出结果[12, 3, 2, 13, 342, 9]

（2）在原值后面追加很多值，且为循环加入

li=[23,234,21,21,1,23]
v=li.extend(["hhh","gfahkg"])
print(li)#输出结果[23, 234, 21, 21, 1, 23, 'hhh', 'gfahkg']

（3）清空 clear

li=[12,3,2,13,342]
v=li.clear()
print(li)#输出结果[]

（4）拷贝 copy

li=[12,3,2,13,342]
v=li.copy()
print(li)#输出结果[12, 3, 2, 13, 342]

（5）计数 count

li=[12,3,2,13,2,2,2,342]
v=li.count(2)
print(v)#输出结果4

（6）根据列表里面的值去找对应的位置（左边优先） index

li=[23,234,21,21,1,23]
v=li.index(234)
print(v)#输出结果为1

（7）从前往后根据位置插入值 inser

li=[23,234,21,21,1,23]
v=li.insert(0,"hf")#insert(位置，元素）
print(li)#输出结果['hf', 23, 234, 21, 21, 1, 23]

（8）删除列表中的值并获取 pop

li=[23,234,21,21,1,23]
#不带值默认删除最后一位
v1=li.pop()
print(li)#输出结果[23, 234, 21, 21, 1]
print(v1)#输出结果23
#带值根据索引（下标）删除
v2=li.pop(2)
print(li)#输出结果[23, 234, 21, 1]
print(v2)#输出结果21

（9）删除列表中的指定值 remove

li=[23,234,21,21,1,23]
v=li.remove(234)
print(li)#输出结果[23, 21, 21, 1, 23]

（10）将列表中的元素倒置翻转  reverse

li=[23,234,21,21,1,23]
v=li.reverse()
print(li)#输出结果[23, 1, 21, 21, 234, 23]

（11）排序 sort

li1=[23,234,21,21,1,23]
li2=[23,234,21,21,1,23]
v1=li1.sort()#默认从小到大排列
v2=li2.sort(reverse=True)
print(li1)#输出结果[1, 21, 21, 23, 23, 234]
print(li2)#输出结果[234, 23, 23, 21, 21, 1]

5、元祖（不可增删改）

创建元祖：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

（1）字符串转化为元祖

s="sjfhfnm"
v=tuple(s)print(v)#输出结果('s', 'j', 'f', 'h', 'f', 'n', 'm')

（2）列表元祖相互转化

li=[123,"dnfj"]
v=tuple(li)#列表转化为元祖
print(v)#输出结果(123, 'dnfj')

tu=(123,"djfi")
v=list(tu)#元祖转化成列表
print(v)#输出结果[123, 'djfi']

（3）元祖循环

tu=(123,"djfi")
for i in tu:
     print(i)
#输出结果
#123
#djfi

（4）join链接

tu=("hdfgy","djfi")
v="_".join(tu)
print(v)#输出结果hdfgy_djfi

（5）获取元祖中元素

tu=(123,"vhf",[(12,14)],("hf",789))
v=tu[2][0][0]
print(v)#结果为12

（6）enumrate方法获取元祖元素和序号

tu= ("alex",'eric','rain')
for item3,item4 in enumerate(tu):
    print(item3,item4)
'''
运行结果：
0 alex
1 eric
2 rain
'''

6、字典（无序）

（1）、创建字典：（“，”号进行分割；一个“：”为键值对；dict类），基本结构   True代表1，False代表0

person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})

info={
    1:123,
    "sd":123,
    (1,2):356,
    # True:999,#bool值可作为key值，但有可能与原有的key值重复
    # {1:12}:444,#字典值不可作为key值
    # [1,2,3]:455#列表值不可作为key值
}
print(info)#输出结果{1: 123, 'sd': 123, (1, 2): 356}

（2）字典索引 v=info[key值]，key值不存在则报错，通常用下下下所述的get方法

　　a、根据key值查找所对应的value值

info={
    1:123,
    'sd':123,
    (1,2):356
}
v1=info['sd']
v2=info[(1,2)]
print(v1)#输出结果123
print(v2)#输出结果356

info={"hj":777}
v1=info.get("hj")
print(v1)#结果为777
v2=info.get("hdjj")
print(v2)#结果为None
v3=info.get("hdjj","没有就显示蝴蝶是我")
print(v3)#结果为：没有就显示蝴蝶是我

　b、查找value值中相关元素  

info={
    1:123,
    'sd':123,
    (1,2):356,
    855:((11,45),22,33)
}
v=info[855]#找出key值所对应的value
v1=v[0][1]#根据value值的数据类型，书写合适的查找方式
print(v1)#输出结果为45

（3）字典删除 del info[key值]，，pop（删除值，并显示删除的值），，popitem（在字典中随机删除）

info={
    1:123,
    'sd':123,
    (1,2):356,
    855:((11,45),22,33)
}
del info[1]#删除格式
print(info)#结果：{'sd': 123, (1, 2): 356, 855: ((11, 45), 22, 33)}

info={"hj":777,1:"aaa"}
v=info.pop(1)
print(info,v)#运行结果：{'hj': 777} aaa

info={"hj":777,1:"aaa"}
v=info.popitem()
print(info,v)#运行结果：{'hj': 777} (1, 'aaa')

（4）字典for循环 for item1 in info.keys():循环输出key值 for item2 in info.values():循环输出value值 for item3 in info.items():循环输出键值对 

　　for k,v in info.items():循环输出键值对

info={
    1:123,
    'sd':123,
    (1,2):356,
    855:((11,45),22,33)
}
for item1 in info.keys():
    print(item1)#不加.keys时，也默认输出key值
'''
输出结果：
1
sd
(1, 2)
855
'''
for item2 in info.values():
    print(item2)#输出value值
'''
输出结果:
123
123
356
((11, 45), 22, 33)
'''
for item3 in info.items():
    print(item3)#获取键值对
'''
输出结果：
(1, 123)
('sd', 123)
((1, 2), 356)
(855, ((11, 45), 22, 33))
'''
for k,v in info.items():
    print(k,v)#获取键值对
'''
输出结果：
1 123
sd 123
(1, 2) 356
855 ((11, 45), 22, 33)
'''

（5）字典的清除和复制（clean、copy）

info={
    1:123,
    'sd':123,
    (1,2):356,
    855:((11,45),22,33)
}
info.clear()
print(info)#输出结果：{}
info.copy()
print(info)#输出结果{}{}

（6）字典静态方法，类名.方法（传参数）

　　a、通过传数列，生成字典，并指定统一的值  dict.formkeys(**,**)

 　　b、进行值的设置，若原字典中有，则不重新设置，将key值所对应的值进行获取；若元字典中没有，则进行设置添加  .setdefault(key,value)

info={"hj":777,1:"aaa"}
v1=info.setdefault(1,999999)#原字典中存在1，所以获取aaa
print(info,v1)#运行结果：{'hj': 777, 1: 'aaa'} aaa
v2=info.setdefault("apple",999999)#原字典中不存在apple，所以进行设置
print(info,v2)#运行结果：{'hj': 777, 1: 'aaa', 'apple': 999999} 999999

　　c、更新字典 updata

info={"hj":777,1:"aaa"}
v1=info.update({1:"yu",5:"abc"})#写法1
print(info)#运行结果：{'hj': 777, 1: 'yu', 5: 'abc'}
v2=info.update(hj=888,k2=2,k3=44444)#写法2
print(info)#运行结果：{'hj': 888, 1: 'yu', 5: 'abc', 'k2': 2, 'k3': 44444}

（7）in方法

info={"k1":"asd","k2":111}
v="k1" in info
print(v)#结果为True

info={"k1":"asd","k2":111}
v=111 in info.values()
print(v)#结果为True

7、range和xrange

（1）指定范围，生成指定的数字

print range(1, 10)
# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
 
print range(1, 10, 2)
# 结果：[1, 3, 5, 7, 9]，2为步长
 
print range(30, 0, -2)
# 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]，-2为步长　

（2）将文字对应的索引打印出来

text=input(">>>")#例如text=“好自为之”
v=len(text)#获取用户输入的字符长度
print(v)# v=4
r=range(0,v)# 指定范围，生成指定数字
for item in r:
    print(item,text[item])#text[xx]——>下标

　　运行结果：