python 备选

4.1 Number  数字

　　数据类型是不允许改变的

　　整数：int   通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，布尔(bool)是整型的子类型。

　　浮点数：float  浮点型由整数部分与小数部分组成

　　复数：complex   复数由实数部分和虚数部分构成

　　　　主要用计算，使用不多，记住以下就行：

　　　　　　加：+  减：-   乘：*   除： /    取余：%   整除：//  幂：**

　　　　取值范围：

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

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

i= 5.8    # 浮点数
print(int(i))  # 转换位 整数 精度损失

s = str(i)         # int 转换为字符串
b = bool(i)         # int 转换为布尔值    只有0是False  非0都是True

　　

　　

 

bool ：布尔型 ，如：True、False

　　　　True    真     1

　　　　False   假     0

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加 True==1，False==0 是会返回 Ture，但可以通过 is 来判断类型。

# 同上  布尔值转换为int  只 能输出 0 和 1    

i = int(True)   
b = int(False)      

while True:
　　pass
while 1:   # 这个效率更高，因为电脑只识别0101二进制，True还要转换以下
　　pass

　　

 

4.2 字符串　String：一般用英文：'内容' , "内容" , ''' 内容：多行'''  ，

　　　　可以相加，可以数字加乘，存放少量数据

同上 字符串转换为 int 或布尔值

c = "123"
b = int(c)      # 注：字符串转换为int 前提条件必须是 数值类型

字符串转换为布尔值

s = ""   --> False
#非空字符串都是True   

s
if s:
　　print('你输入的为空，请重新输入')
else:
　　pass

　　

# 字符串的索引与切片

s = 'ASDFGHJKL'

#索引  字符串有一定顺序，且从0开始
s1 = s[0]     # 新的s1与上面的s已经没有任何关联
print(s1)
>> A

s3 = s[-1]    # 如果字符串很长，我又去最后几位 就可以倒着取
print(s3)
>> L

# 切片  取前不取后
s2 = s[0:4]   # 不影响s哦
print(s2)
>> ASDF

s4 = s[0:] # 全部取，你以为是 = [0:-1]  你会发现最后一位没取，记得取后不取前
s5 = s[:]   # 也可以这样写哦！
print(s4,s5)
>> ASDFGHJKL ASDFGHJKL

# 跳这取 s[首:尾:步长]
s6 = s[0:6:2]
print(s6)
>> ADG

# 倒着切
s7 = s[4:0:-1]
print(s7)
>> GFDS
s8 = s[4::-2]  # 倒着跳取 到最前面那位
print(s8)
>> GDA
s9 = s[-1::-1]  # 倒着取完
print(s9)
>> LKJHGFDSA
s10 = s[::-1]  # 倒着取完另一种方法
print(s10)
>> LKJHGFDSA

　　

　

# 字符串的操作
s = 'asdfghj'

# capitalize       首字母大写
s1 = s.capitalize()
print(s1)
>> Asdfghj

# upper   全部大写
s2 = s.upper()
print(s2)
>> ASDFGHJ
'''
# 一道题 请输入验证码的题
s21 = 'sdFG'
s22 = input("请输入验证码，不区分大小写 ")
if s21.upper() == s22.upper():
    print('验证码正确')
else:
    print('验证码错误')
'''

# lower       全部小写
s3 = s.lower()
print(s3)
>> asdfghj

# swapcase   大小写翻转
s4 = s.swapcase()
print(s4)
>> ASDFGHJ

# title    每个隔开（特殊字符或数字）单词首字母大写
s5 = 'asd vbn fgh'
s51 = s5.title()
print(s51)
>> Asd Vbn Fgh

# center  填充
s6 = s.center(20)     # 居中填充 不写默认空白填充
s61 = s.center(10,'*') # 可以跟参数 10是算字符串总的为 不满用参数填充
print(s6,s61)
>>       asdfghj        *asdfghj**

# \t     加上前面所占不到8位补8位，超过8位不足16位补16位
s7 = 'fg\tkl'
s71 = s7.expandtabs()
print(s71)
>> fg      kl

# len   计算字符串长度
s8 = len(s)
print(s8)
>> 7

# startswith    判断字符串是否以什么开头只能返回 True和False  ，后面不加条件 就判断整体
s9 = 'asdDFG'
s91 = s9.startswith('a')
s92 = s9.startswith('d',2,5)  # 可以切片判断
print(s91,s92)
>> True True

# find   通过元素 找元素所占的索引，找不到就返回-1
s9 = 'asdDFG'
s10 = s9.find('D')
s101 = s9.index('D') # 另一种方法  找不到会报错 ，首选find
print(s10,s101)
>> 3 3

# strip   删除前后元素 默认删除前后空格
s11 = '  hjkl  '
s111 = s11.strip()
s112 = '$%kljflk*'
s113 = s112.strip('*$%') # 可以加参数，里面不按顺序
s114 = s112.rstrip('*$%')  # 从右删，左边不动，同理 lstrip：从左删 右边不动
print(s111,s113,s114)
>> hjkl kljflk $%kljflk

# 附一道小题
# username = input('请输入你的名字：')
# if username.strip() == '小米':
#     print('答对了')

# count 计数
s12 = s.count('a') # 数字符串所有的元素，也可以两个一起'as'
print(s12)
>> 1

# split  分割 也是字符串转换成列表的一种方式
s13 = 'kjh jkjhk kjhjk'  
s131 = s13.split()  # 括号里是参数，分隔后参数是不显示的
print(s131)
>> ['kjh', 'jkjhk', 'kjhjk']

str.split(str="", num=string.count(str)) 
# 第一个是以哪个参数分割 ，num这个字符串里有多个参数 分割次数，num有指定值则分割num+1，默认为-1，即分割所有
s = 'alexwusirlex'
li = s.split('l',1) # 以l分割第一个
print(li)

#>> ['a', 'exwusirlex']

#format 格式化输出
s14 = '我叫{},今年{},喜欢{}'.format('huang',25,'girl')
s141 = '我叫{0},今年{1},喜欢{1}'.format('huang',25,'girl')
s142 = '我叫{name},今年{age},喜欢{hobby}'.format(name='huang',age=25,hobby='girl')
print(s14,s141,s142)
>> 我叫huang,今年25,喜欢girl 我叫huang,今年25,喜欢25 我叫huang,今年25,喜欢girl

# replace 替换
s15 = '我来看你了你知道吗你知道吗'
s151 = s15.replace('知道','haha',1) # 替换 目标，值 ，有相同的第几个
print(s151)
>> 我来看你了你haha吗你知道吗

　　

　　

　　

　

　　tuple：元组，元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。

　　　　例：（1，2，3）（"a","b","c"）

# 元组 只读列表 可循环查询 可切片  儿子不能改 孙子可能可以改

ts = ('name','age','column',[1,2,'hello'],'man')
print(ts[3][2])  # 查
>> hello

ts[3][2] = ts[3][2].upper()  # 改孙子元素
print(ts)
>> ('name', 'age', 'column', [1, 2, 'HELLO'], 'man')

ts[3].append('ha')  # 添加
print(ts)
>> ('name', 'age', 'column', [1, 2, 'hello', 'ha'], 'man')

# python range() 函数可创建一个整数列表，一般用在 for 循环中。
#
#  函数语法
#  range(start, stop[, step])
#  参数说明：
#  start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
#  stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
#  step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

for i in range(0,10):  # (开始，结束，步长)
    print(i)
>> 0 1 2 3 4 5 6 7 8 9
for s in range(10,0,-2):
    print(s)
>> 10 8 6 4 2
for d in range(3,-10,-2):
    print(d)
>> 3 1 -1 -3 -5 -7 -9

　　

# 一道题 两种方法参考
li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']  # 都打印出来 包括里面的列表元素
# for i in li:
#     if type(i) == list:
#         for k in i:
#             print(k)
#     else:print(i)

for i in range(len(li)):
    if type(li[i]) == list:
        for j in li[i]:
            print(j)
    else:print(li[i])

　　

　　

　　

　　list：列表：[] 括起来，每个元素以逗号隔开，可以存储大量数据，而且他里面可以存放各种数据类型比如：

　　　　li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

　　　　列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。

　　　　而且列表是有序的，有索引值，可切片，方便取值。

# 列表 增删改查

# 增加 append          还在基础上增加 没有创建新的
p.append('happy,new year')
print(p)

# HR 输入名字 持续增加 当输入Q的时候 就退出
# while 1:
#     username = input('>>>')
#     if username.strip().upper() == 'Q':
#         break
#     else:
#         p.append(username)
#         print(p)

# insert 插入
p.insert(4,'老铁')
print(p)

# extend 插入可迭代的元素
p.extend('你好')
p.extend([1,2])
print(p)

# 删 pop
p2 = p.pop()  # 有返回值 不填参数 默认删最后一个
p21 = p.pop(4)  # 指定索引位删
print(p,p2,p21)

# remove 按元素删
p.remove('i love you')
print(p)

# clear 清空列表 但不删列结构
p.clear()
print(p)

# del
del p[0:2]  # 切片删
del p   # 全删包括列
print(p)   # 你会发现报错 ，因为没有了，所以他肯定报错

# 改
p[0] = '你好'   # 直接对应的 索引位改
p[0] = [4,5,6]    # 也可以直接改列表
p[0:3] = '你好' # 把前三个删了 划分到最小的元素添加
p[0:3] = ['hao','ba'] # 添加列表里每一个元素
print(p)

# 查
print(p[0:4])  # 直接查
l = len(p)  # 查列表长度
print(l)

# count 查一个元素的次数
print(p.count('ba'))

# index  查元素在列表中的索引位
print(p.index('hao'))

# sort 排序
s = [1,6,5,9,10]
s.sort()      # 正向排序
print(s)

s.sort(reverse = True)  # 倒向排序
print(s)

s.reverse()  # 翻转
print(s)

# 列表的嵌套

t = ['xiaomi','haha','happy new year',1,2]
print(t[1][1]) # 找里面元素的元素
name = t[1].capitalize()  # 所选的元素的首字母大写，但里面本质没有改变
print(name)
print(t)
t[0] = name # 这样里面元素已经改变
print(t)
print(t[2].replace('h','好')) # 里面元素替换
t[2] = t[2].replace('h','好')
print(t)

# 列表转换成 字符串 join 字符串转换成列表 split
s ='huang'
s1 = '+'.join(s)  # 可以对可迭代对象任何操作
print(s1)

#>> h+u+a+n+g

# ''.join()
li = ['alex','wusir','rain']
s2 = ''.join(li)
print(type(s2))
print(s2)

#>> <class 'str'>
#>> alexwusirrain

　

　

　

　　dict：字典，用{ } 括起来，key不存在重复

'''
# dict
# 数据类型划分：可变、不可变
# 不可变 ：元组、bool、int、str  可哈希
# 可变：list、dict、set         不可哈希

# dict key 必须是不可变得数据类型   可哈希
       value  任意数据类型。
dict 优点：二分查找去查询、存储大量的关系型数据
     特点：3.5版之前是无序的
            
       
'''

dict = {
    'name':'小米',
    'age':'18',
    'p1':[{'xuexi':15},20]
}

# 增
dict['hello'] = 'world'
print(dict)
# >> {'name': '小米', 'age': '18', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}

# 如果有了 会直接覆盖掉
dict['age'] = 25
print(dict)
# >> 'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}

# setdefault
dict.setdefault('身高') # 没有vlaue会填充None
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
dict.setdefault('age','20') # 对里面有键值对，不做任何改变，没有参会添加
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}

# 删
# pop
print(dict.pop('age')) # 有返回值
print(dict)
# >> 25
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
print(dict.pop('age',None))  # 如果字典里没有你要删除的键值对，你就要加个返回值，可自定义 防止报错飘红
print(dict)
# >> None
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}

# popitem
print(dict.popitem()) # 删除最后一个，3.5以前随机删除 ，返回值 删除的键值对
print(dict)
# >> ('身高', None)
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}

# del
del dict['name']  # 所在键值对不在时会报错
print(dict)
# >>{'p1': [{'xuexi': 15}, 20], 'hello': 'world'}

dict.clear()  #     清空字典
print(dict)
# >> {}

# 改
# 直接改
dict['age'] = 18
print(dict)
# >> {'age': 18}

# update
dict1 = {'name':'xiaomi','hello':'world'}
dict.update(dict1) # 把dict1的全部键值对 添加到 dict ，相同的覆盖
print(dict1)
print(dict)
# >> {'name': 'xiaomi', 'hello': 'world'}
# >> {'age': 18, 'name': 'xiaomi', 'hello': 'world'}

# 查
print(dict.keys())
print(dict.values())
print(dict.items())
# >> dict_keys(['age', 'name', 'hello'])
# >> dict_values([18, 'xiaomi', 'world'])
# >> dict_items([('age', 18), ('name', 'xiaomi'), ('hello', 'world')])

v1 = dict['name'] # 输出是值，没有就会报错
print(v1)
# >> xiaomi

# get
print(dict.get('name'))  # 有就会直接返回值 没有就会返回None
print(dict.get('name2','没有这个值')) # 也可以自定义
# >> xiaomi
# >> 没有这个值

a,b = 1,2
a,b = [1,2]
a,b = [1,2],[3,4]
print(a,b)
# >> 1 2
# >> 1 2
# >> [1,2] [3,4]
# 用一行代码把 a b 值交换
a = 1
b = 2
a,b = b,a
print(a,b)
# >> 2 1

# 一一对应，接受值
for k,v in dict.items():
    print(k,v)

# 嵌套
dic = {
    'name':['xiaomi','zhangsan','lisi'],
    'jihe':{
        'time':'123',
        'learn_money':19800,
        'leader':'huang'

    },
    'age':18
}
# 改
dic['age'] = 25
print(dic)
#>> {'name': ['xiaomi', 'zhangsan', 'lisi'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'].append('leader')
print(dic)
# >> {'name': ['xiaomi', 'zhangsan', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'][1] = dic['name'][1].upper()  # 其中一个值改大写
print(dic)
# 》{'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['jihe']['gou'] = 8
print(dic)
# >> {'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang', 'gou': 8}, 'age': 25}


# 一道题
f = input('>>>')
for i in f:
    if i.isalpha():
        f = f.replace(i,'')
o = f.split()
print(o)
print(len(str(o)))

　　

　

　　set：集合，用{ } 括起来，集合是无序的，不重复的数据集合，里面的元素是不可变类型

 # is 比较，比较的事内存地址

'''
# 集合：可变的数据类型，它里面的元素必须是不可变得数据类型，无序，不重复，{}
set = {1,'sdfsd',2,3,'hello'}

# add 增加
set.add("name")
print(set)
# >> {1, 2, 3, 'name', 'sdfsd', 'hello'}

# update
set.update('leader')
print(set)
# >> {1, 2, 3, 'hello', 'a', 'd', 'name', 'l', 'r', 'sdfsd', 'e'}

#  pop 删除
set.pop()
print(set.pop())  # 随机删除 有返回值
print(set)
# 》 1
# 》 {2, 3, 'd', 'r', 'l', 'sdfsd', 'hello', 'a', 'e'}

# remove
set.remove(2) # 按元素去删
print(set)
# 》{'sdfsd', 1, 3, 'hello'}

# clear  清除集合
set.clear()
print(set)
# >> set()

# del 删除整个集合
del set
print(set)
# >> <class 'set'>

# 查
for i in set:
    print(i)

# 求交集
set1 = {1,2,3,4,"hello"}
set2 = {1,4,2,5,"world"}

set3 = set1 & set2      # 第一种
print(set3)
# >> {1, 2, 4}
print(set1.intersection(set2))       # 第二种
# 》 {1, 2, 4}

# 求并集
print(set1 | set2)
# 》 {1, 2, 3, 4, 5, 'world', 'hello'}
print(set1.union(set2))
# >> {1, 2, 3, 4, 5, 'world', 'hello'}

# 反差集
print(set1 - set2)
# 》 {'hello', 3}
print(set1.difference(set2))
# >> {3, 'hello'}

# 子集 超集
print(set1 < set2)
print(set1.issubset(set2))   # 这两个相同，若返回True 则set1是set2子集

print(set2 > set1)
print(set2.issuperset(set1))     # 这两个相同，若返回True 则set2是set1超集
'''
# set 本身是可变数据类型，但可以让他变成不可变数据类型，冻住
s = frozenset('barry')
print(s,type(s))
# >>frozenset({'b', 'r', 'a', 'y'}) <class 'frozenset'>


# 一道小题 去重
li = [11,22,33,33,44,55,66,66,77]
set5 = set(li)
print(set5)
li = list(set5)
print(li)

　　

　　complex：复数 

　　float：浮点型 ，如：12.20

　　注：

　　　　type()：查看数据类型的方法

　　　　字符串转换成数字：int(str)    ，条件str必须是数值组成

　　　　同样数字转换成字符串：str(int)

　　　　用户交互input输出的全部是 str