python 小数点变百分数 python小数转换为百分数

1、算数运算符：

+   -  *  /   **    %  //  

num=9%2

print(num)

num=9%2
print(num)


num=9//2
print(num )

2、成员运算

name='苟陇辉'
 if '苟' in name:
    print('ok')
else:
    print('error')

 if '苟'not in name:
    print('ok')
else:
   print('error')

in             not in   判断某个东西是否在某个东西中包含。

3、逻辑运算

布尔值：  结果 为‘真’  true   或者 结果为  ‘假’  false

# '' 空字符为假

# '   '  只要里面有东西 就为真

#  0    假

# 其他  真

  ‘转换bool值     

a=123

b=bool(a )’

name='苟陇辉'
v= '苟' in name
print(v)

user='gou'
pwd=123
v=user=='gou' and pwd==124 or user=='ales'and pwd=='123' print(v)

4、赋值运算

count=1

count=count+1  即  count+=1

count=count%1 即 count%=1

5、比较运算

a= 1>5

print(a)

结果为 false

总结： 算数运算符 和 赋值运算符 得到的均为‘’真实‘’结果；比较运算符、 逻辑运算符、成员运算得到的结果均为“布尔值” 

针对逻辑运算的进一步研究：

　　1,在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。

　　2 ,  x or y , x为真，值就是x，x为假，值是y；

             x and y, x为真，值是y,x为假，值是x。

　

基本数据类型

 一、整形  int   

注：在Python3中，无论数字多大，都属于int类型；在Python2中，数字变大，超过一定范围则称为long型；

魔法  

1、转换功能

a='123'
print(type(a),a)     # type 查看类型 
b=int(a)             # 将字符串'123'，转换为数字123
print(type(b),b)

a='0011'
v=int(a ,base=2)    # base=16/8/2  指代以16进制数，8进制数，2进制数表示a, 若是不写base=  则默认10进制数
print(v)

2、

age=10
r=age.bit_length()    #表示当前数字的二进制，至少用多少位表示  10的二进制数为1010 即4位
print(r)

 

二、字符串

魔法 

1、

test='gou'
v=test.capitalize()         #表示首字母大写，其他字母小写
print(v)

2、

test='gou'
v=test.casefold()          #表所有字母变小写
print(v)

注意：

test='gou'
v=test.lower()          #也表所有字母变小写，但是特殊字符表示不了。而capitalize（）则对于很多未知的对应关系也可以表示
print(v)

3、

test='gou'
v=test.center(20,'*')       # 表示  设置宽度，并将内容居中，其中20代表总长度，'*'代表空白处的未知填充，只能有一个字符，可有可无
print(v)

标准为：test.center(width,fillchar=None）

# print(test.ljust(20, '*'))  # gouLONGhui**********
# print(test.rjust(20, '*'))  # **********gouLONGhui
# print(test.zfill(20))  # 0000000000gouLONGhui 默认为0填充，无法设置参数

4、

test='gougou'
v=test.count('ou')      # 去字符串里寻找子序列（'ou'）出现的次数
print(v)

 

test='gougou'
v=test.count('ou',5,8)      # 去字符串里寻找子序列（'ou'）出现的次数,指定寻找的起始 和 结束 位置  注意字符串第一位为0
print(v)

5、

test='gou'
v=test.endswith('ex')      #  字符串以什么结尾 
print(v)                   #  v=test.startswith('a') 表示字符串以什么开头

 

6、

test='gougou'
v=test.find('ou',5,8)       # 从开始往后找，获取其位置,索引 ，可指定其寻找的起始位置，注意，大于等于5，小于8
print(v)

注意：找不到时 结果为-1

7、

test='gougou'
v=test.index('8')           #  从开始往后找，获取其位置 ，可指定其寻找的起始位置,找不到时程序报错，故一般使用find命令，找不到时 运行结果为-1
print(v)

 

8、

test='i am {name},age{a}'
v=test.format(name='gou',a=19)     # 格式化，将一个字符串的占位符替换为指定的值。注意格式的准确性，括号必须为大括号
print(v)

test='i am {name},age{a}'
v=test.format_map({'name':'gou','a':19})     # 也是格式化，将一个字符串的占位符替换为指定的值。注意格式的准确性，冒号不能少
print(v)

 

9、

test='syeijc435_+'
v=test.isalnum()        # 判断字符串中是否只包含字母和数字，若有其他符号 ，则结果为false
print(v)

10、

test='tuys'
v=test.isalpha()        # 判断字符串是否只包含字母 汉字
print(v)

11、

test='124'
v=test.isdecimal()      # 判断字符串是否只包含数字
print(v)

test='12'
v=test.isdigit()         # 判断字符串是否只包含数字          
print(v)

 

 二者的区别为  若为 ② 则 .isdecimal 为false       . isdigit 为true   

test='二2②'
v=test.isnumeric()      # 判断是否全为数字  可识别汉字
print(v)

.isnumeric 也可识别 汉字‘二’

12、

test='_123rt'
v=test.isidentifier()       # 判断 标识符 格式是否正确  注意：标识符同字符串规则一样，不能使用数字开头
print(v)

 

13、

test='\totijd\n'
v=test.isprintable()        # 判断是否存在不可见的（如\n、\t) ，或运行结果不可显示的字符  
print(v)

 

14、

test='    '
v=test.isspace()        # 判断是否字符串全为空格
print(v)

 

15、

test='Gou long hui'
v=test.istitle()        # 判断是否为标题（标题中每一个首字母都需大写）
print(v)
v=test.title()      # 转换为标题
print(v)

test1 = 'gou sf\tsf h6ui'
print(test1.title())  # Gou Sf    Sf H6Ui 非字母隔开的每个单词首字母大写

16、

test='aeiou'
test1='12345'   #  获得对应关系
v='asidou'
v1=str.maketrans('aeiou','12345')       # 替换功能
new_v=v.translate(v1)
print(new_v)

 

17、

test='gou'
v=test.swapcase()       # 大小写转换
print(v)

 

17、

test='username\temail\tpassword\ngoulonghui\[e-mail]\t123\nweiguoquan\[e-mail]\t234'
v=test.expandtabs(20)       # 从开始往后找制表符'\t'，20个一组，找到后用空格自动补齐20，可用于制作表格
print(v)

 

必背魔法：

1、

test='gouex'
v=test.find('ex')       # 从开始往后找，找到第一个之后，获取其位置
print(v)

 

test='gouex'
v=test.rfind('ex',2,5)      # 从右往左找，规定范围在>=2,<5,之间，获取其位置, 注意：无论从左往右还是，从右往左数，都是左边第一个字符 索引为0
print(v)

 

2、

test='苟陇辉五六七八九'
v='_'.join(test)        # 将字符串中的每一个元素按照指定分隔符拼接。 注意    .join
print(v)

l = ['s', 'f']
print(''.join(l))  # sf   只有列表中元素全是字符串时，才可将列表转换为字符串

3和4 、

test='gou'
v1=test.islower()       # 判断字符串是否全为小写
v2=test.lower()         # 将字符串全部转换为小写
v3=test.isupper()       # 判断字符串是否全为大写
v4=test.upper()         # 将字符串全部转换为大写
print(v1,v2,v3,v4)

5、

test='  xgou  '
test1='al\te\tx'
# v1=test.lstrip()          # 去除左边空格
# v2=test1.lstrip()         # 去除‘\t’‘\n’
# v3=test.rstrip()          # 去除右边空格
# v4=test1.rstrip()         # 去除‘\t’‘\n’
# v5=test.strip()           # 去除两边空格，不能去除中间空格
# v6=test1.strip()          # 去除‘\t’‘\n’
test2='xgou'
v7=test2.lstrip('xa')       # 去除指定字符
print(v7)


6、

test='testasdsddfg'
v1=test.partition('s')      # 以目标's'分割，找到第一个s后分，只能分割三块
v2=test.rpartition('s')     # 以目标's'分割，从右找 找到第一个s后分，只能分割三块
v3=test.split('s',)         # 以目标's'分割，找到第一个s后分，但是不显示分割字符s
v4=test.rsplit('s')         # 以目标's'分割，从右找到第一个s后分，但是不显示分割字符s
v5=test.split('s',2)        # 以目标's'分割，找到2个s后停止分割，且不显示分割字符s
print(v1)
print(v2)
print(v3)
print(v4)
print(v5)

特例：test.splitlines()  表示根据换行符‘\n’分割      test.splitlines(True) 则显示换行符‘\n’， test.splitlines(False),则不显示换行符‘\n’。

7、

test='gougougou'
v=test.replace('ou','bbb',2)        # 替换功能
print(v)

 

特殊用法：

1、

test='gou'
v=test[2]           # 据 索引 或 下标 获取字符串中的某个字符
print(v)
v2=test[0:2]        # 索引范围 左开右闭，顾头不顾尾
print(v2)
v3=len(test)        # 判断当前字符串有多少字符组成
print(v3)

2、for

test='苟陇辉苟'
index=0
while index<len(test):
    v=test[index]
    print(v)
    index+=1
print('====')

使用for语句时：

test='苟陇辉苟'     # for 循环格式   for 变量名 in 字符串：
for v in test:      #                    变量名
    print(v)

 

字符串一旦创建，不可修改；

一旦修改或者拼接，都会造成重新生成字符串；

补充：

range的用法    帮助创建连续的数字，v=range（0,100,5）步长为5

                 v='gougougou'

replace      v=test.replace('ex','bbb',2)   2为替换前2个

 

练习题：将用户输入的文字及其对应的索引打印出来。

test=input('请输入：')
v=range(0,len(test))
for item in v:
    print(item,test[item])

 三、列表list

list 为类，li为通过list类创建的对象，列表里每一个元素通过， 隔开，中括号 括起来；可以修改，删除

方法

1、

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'gou',True]

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'gou',True]
print(li[3])            #
print(li[3:5])
li[1] = 120
print(li)
li[1] = [11,22,33,44]
print(li)
li[2:4] = [120,90]
print(li)
del li[1]
print(li)
del li[2:6]
print(li)           # 可通过索引、切片 取值，删除其中的元素

 

同样支持for循环，while 循环

2、in 操作

v = 12 in li

print(v)        True

 

3、

li = [1,12,9,'age',['苟陇辉',['19','10'],'你'],'gou',True]
v = li[4][1][0][1]　　　　　　# 索引取值一直往里找
print(v)

结果为9
4、
（1）

s = 'asdfghkl'
list(s)             # 转化功能   字符串转化为列表，内部使用的for循环，注意： 数字不可被转化，不可使用for循环
print(list(s))

 

（2）、列表转化字符串

①：列表中既有数字，又有字符串是 需要自己写一个for循环一个一个处理：

li=[1,2,3,'gou]

s=''

for item in li

　　s=s+str(item)

print(s)

② 只有字符串

li=['123','gou']

v=''.join(li)

print(v)

一般方法：

1、

li = ['11','22','33','44']
li.append(5)            # 直接在原值后面追加一个
print(li)
li.append([99,'苟陇辉'])      # 只将一个整体以列表的形式加进去
print(li)
li.extend([99,'苟陇辉'])       # 将每一个元素都加进去
print(li)

 

2、

li = ['11', '22', '33', '44']
v = li.copy()                       # 浅拷贝   
print(v)

 

3、

li = ['11', '22', '33', '44','22']
v = li.count('22')                  #  计算‘22 ’出现的次数
print(v)

 

4、

li = [11,22,33,22,44]
v = li.index(22)                # 寻找当前元素的索引，找到第一个之后就不在找了
print(v)
v = li.index(22,2,4)            # 可加起始位置
print(v)
v = li.insert(0,99)             # 在指定位置0， 插入指定元素99
print(v)

5、

li = [11,22,33,22,44]
li.reverse()                        # 将当前列表进行反转
print(li)
li.sort()                           # 排序，从小到大排序
print(li)
li.sort(reverse=True)               # 从大到小排序
print(li)

 

6、删除

li = [11,22,33,22,44]
v = li.pop()                # 默认删除最后一个元素
print(li)                   # 获取删除后的列表
print(v)                    # 获取删除的值
li.pop(1)                   # 删除指定索引的元素
print(li)
print(li.pop(1))

li = [11,22,33,22,44]
li.remove(22)               # 删除指定的元素
print(li)

li.clear()                  # 清空列表
print(li)

 

li = ['gou', 2, 0, True, [1, 2, 3], 'gou long hui']

del li  # 在内存级别删除
print(li)  # NameError: name 'li' is not defined
del li[1]  # 按照索引删除
print(li)
del li[:-1]  # 按照索引删除
print(li)
del li[:-1:2]  # 可加步长
print(li)

四、元祖  tuple

类：元祖   按照元祖类创建的对象 tu ；       #  元祖是对列表的二次加工；  小括号括起来，最后面加一个逗号“，”；

注：元祖（一级元素）不可被修改，不能被增加或者删除；   有序的；

tu = (111,'gou',(,),[()],True,33,44,)

 常用方法：

1、索引取值：v = tu[0]

2、切片取值：v = tu[0:2]

3、支持for循环

4、相互转换：s li tu

v = tuple(s)   v = tuple(li)

v = list(tu)     v = '_'.join(tu)（ 只有字符串时）

一般方法：

count  ： v = tu.count(33)    获取元素33  在 tu中出现的次数

index   :   v = tu.index(111)   获取元素 111  在tu中的索引    左边优先

五、字典 dict

1 基础数据类型之一，{} 以键值对的形式存储数据。
 2     dic = {'name':'Laonanhai',
 3             'age':45,
 4             'name_list':['反面教材','俊俊',....]
 5             }
 6     以key：value形式，映射，存储的大量的关系型数据。
 7     数据类型的分类：
 8         可变(不可哈希hash)：list，dict，set， list = [11,222,333]
 9         不可变(可哈希hash)：str，tuple，int，bool   name = 'gou'
10         容器类：
11             容器类的数据类型：list，tuple，dict, l1 = [11,True,'gou',[22,33,44]]
12             非容器类的数据类型：str，int，bool。 s1 = '[11,22,33]'
13     字典的key必须是不可变的数据类型，是唯一的，
14         hash算法：
15             字典的键通过hash表转换成数字，采用二分查找查询数字。每次取中间的数向两边去查找。
16     字典的value可以是任意数据类型。
17     字典的查询速度非常快，存储的大量的关系型数据。
18     字典在python3.5包含3.5之前都是无序，但3.6之后是有序的。

 

对象   info = {'k1':'v1','k2':'v2'}

info = {'k1':18,

           'k2':true

           'k3':[11,22,33,{'kk1':'vv1','kk2':'vv2'},'kk3':(11,22,)]

           'k4':(11,22,33)}

注意： value  可是任意值

             key    列表，字典，不可为key ；bool值  True  默认=1   False  默认=0，若是重复是  则不显示

1、字典是无序的

2、取值：据K取值，即据索引取到指定元素 ，但不可使用切片（因为字典是无序的）。

3、删除：据K删除      del info ['k3']['kk1']

4、支持for循环 

for item in info         ==       for item in into.keys      默认循环‘k’

　　print(item)   

for item in info.values        循环‘values’

　　print(item)

for (k,v) in info.items()       循环K,V

　　print(k,v)

5.v = dic.get('k1','111')    根据k获取值，key不存在时，可以可指定输入结果 111   不指定值时，默认结果为none

   print（v）

6 、v = dic.pop('k1',90)     找不到K值时，不报错，可指定 90  结果    注意：不写k时，默认删除最后一个

      print(dic,v)   其中v 为删除的值   

      dic.popitem  随机删除

7、v = dic.setdefault('k',123)   

   设置值，若key以存在，则不设置，获取当前k对应的值； 不存在时，设置并获取当前K对应的值

8、dic.uptade({'k1':'1234','k3':'3333'})    更新字典，若K以存在，则更新其V，若K不存在，加一个进去。

1 dic = {'name': 'alex', 'age': 44, 'gender': '男'}
 2 # 增
 3 # dic['name'] = 'gou'  # 有则覆盖
 4 # dic['hobby'] = 'girl'  # 无则添加
 5 # print(dic)
 6 # dic.setdefault('name', 'long')
 7 # print(dic.setdefault('name', 'long'))   # alex  # 返回其对应的value
 8 # print(dic)  # {'name': 'alex', 'age': 44, 'gender': '男'} 有则不变
 9 # dic.setdefault('hobby', 'girl')  # girl  返回其对应的value
10 # print(dic.setdefault('hobby', 'girl'))  # {'name': 'alex', 'age': 44, 'gender': '男', 'hobby': 'girl'} 无则添加
11 # print(dic)
12 
13 # 删
14 # print(dic.pop('name'))  # 返回删除的value
15 # print(dic)
16 # print(dic.popitem())  # 返回('gender', '男') 随机删除
17 # print(dic)  # {'name': 'alex', 'age': 44}
18 # dic.clear()
19 # print(dic)
20 # del dic
21 # print(dic)  # NameError: name 'dic' is not defined
22 # del dic['name']
23 # print(dic)
24 
25 # 改
26 # dic['name'] = 'GouLongHui'
27 # print(dic)
28 # dic1 = {'k1': '22', 'k2': '66'}
29 # dic2 = {'k1': '11', 'k3': '88'}
30 # dic2.update(dic1)
31 # print(dic2)  # {'k1': '22', 'k3': '88', 'k2': '66'}
32 
33 # 查
34 # print(dic['name'])
35 # # print(dic['name1'])  # 找不到报错
36 # print(dic.get('name'))
37 # print(dic.get('name1', '不存在键'))
38 # print(dic.keys(), type(dic.keys()))  # <class 'dict_keys'>
39 # print(list(dic.keys()), type(list(dic.keys())))  # 相互转化
40 # print(dic.values(), type(dic.values()))  # <class 'dict_values'>
41 # print(str(dic.values()), type(str(dic.values())))  #
42 # print(dic.items(), type(dic.items()))  # <class 'dict_items'>
43 # print(list(dic.items()), type(list(dic.items())))
44 # for i in dic.keys():
45 #     print(i)
46 # for i in dic.values():
47 #     print(i)
48 # for i, v in dic.items():
49 #     print(i, v)

dic的增删改查

dic = dict.fromkeys('abc', 666)  # 生成一个字典,迭代着去将第一个参数中的元素拿出来,当做字典的key,
print(dic)  # {'a': 666, 'b': 666, 'c': 666}
dic1 = dict.fromkeys([11, 22, 33], 'gou')
print(dic1)  # {11: 'gou', 22: 'gou', 33: 'gou'}

六、BOOL值

注意：转换为bool值  ：  bool()

     假：  空字典，空列表，空元祖，空字符串，0

其余均为真。

 总结：

可变：列表，字典

不可变：字符串，数字，元祖                  验证方式:name = 'gou'  id(name)  可查看其储存ID

 

访问顺序：①：直接访问：数字

                  ②：顺序访问（即索引）：字符串、列表、元祖

                  ③：映射：字典

存储元素个数：

                      容器类型：列表、元祖、字典

                       原子： 数字、字符串

七、集合：   s = {,,,}

定义：①：不同元素组成

           ②：无序

           ③：集合中的元素必须是不可变类型：数字、字符串、元祖

方法：

# 集合：
# s = set('hello')            # 定义一个集合
# print(s)

# s = {1,2,3,4,5,'6'}
# s.add('2')                  # 添加一个元素
# print(s)

# s = {1,2,3,4,5,'6'}
# s.clear()                   # 清空列表
# print(s)

# s = {1,2,3,4,5,'6'}
# s1 = s.copy()                 # 复制
# print(s1)

# s = {1,2,3,4,5,'6'}
# s.pop()                         # 随机删
# print(s.pop())                 # 有返回值,删除那个返回那个
# print(s)

# s = {1,2,3,4,5,'6'}
# s.remove('6')               # 指定元素删除，找不到时报错
# s1 = s.discard('6')         # 指定元素删除，找不到时不报错,返回值为None

# v = ['aaa','bbb','ccc']
# v1 = ['aaa','bbb','eee']
# s = set(v)
# s1 = set(v1)
# print(s,s1)
# print(s.intersection(s1))   # 交集
# print(s&s1)                 # 交集
#
# print(s.union(s1))          # 并集
# print(s|s1)                 # 并集
#
# print(s.difference(s1))     # 差集
# print(s1.difference(s))     # 差集
# print(s-s1)
#
# print(s.symmetric_difference(s1))   # 交叉补集
# print(s^s1)                         # 交叉补集
#
# s.difference_update(s1)             # 差集之后 将得到的集合赋值给给s (即更新）
# print(s)

# s1 = {1, 2}
# s2 = {1, 2, 3, 4}
# print(s1.issubset(s2))   #    结果为 True   s1是s2的子集
# print(s1 < s2)           # 子集
# print(s2.issuperset(s1))  #   True   s2是s1的父集
# print(s2 > s1)            # 父集 (超集)
# s1.update(s2)    # 更新多个值
# s1.add(5)  # 更新一个值
# s1.union(s2)     # 不更新
# print(s1)

# s = set( )        # 定义可变的集合
# s = frozenset()   # 定义不可变的集合

# names = ['gou','glh','gou','wc']          #  简单去重
# s = set(names)
# print(s)
# names = list(s)

八、字符串格式化

字符串格式化：

一：百分号方式
#  %s 均可接收    %d 只能接收数字类型   %f 浮点数（小数）
# msg = 'i am %s my hobby is %s' %('glh','gou')     # %.2s代表截取字符串的长度为2
# print(msg)

# tpl = 'percent%.2f' %(99.895652)        #2代表保留2位小数
# print(tpl)
# tpl = 'percent%.2f %%'%(99.895652)      # 打印百分比
# print(tpl)
# 
# tpl = 'i am %(pp).2f' %{'pp': 123.456}   #  后边为字典
# print(tpl)
# 
# msg = 'i am %(name)+60s %(age)d'%{'name': 'glh','age': 23}      # +号表示右对齐并补齐60位
# print(msg)
# msg = 'i am \033[46;1m%(name)+60s\033[0m my hobby is gou ' %{'name': 'glh'}        # 加颜色
# print(msg)
# 
# print('root','x','x','o',sep=':')  # 分别得到结果 后拼接成一条记录    结果为  root：x:x:o
 
# 二 format 字符串格式化

# tpl = 'i am {},age{},{}'.format('glh','23','gou')
# print(tpl)
# tpl = 'i am {2},age{1},{0}'.format('glh','23',['gou',23])      # 相当于按照后面后面元祖索引取值
# print(tpl)

# #  .format('seven',18) == .format(*['seven',18])
# #  .format('seven',18) == .format(**{'seven',18})

# tpl = 'numbers: {:b},{:o},{:d},{:x},{:X},{:%}'.format(15,15,15,15,15,15.89632)
# print(tpl)
# # 结果为numbers: 1111,17,15,f,F,1589.632000%   上述分别代表打印二进制 八进制 十进制 十六进制小写 十六进制大写 转换为百分数，默认保留6位

# 第三种
s = 'hello'
s1 = 'sss'
s3 = 'lao'
print(f'你好{s1}{s3}{s}')  # 前边加一个f,只有python3.6以上的版本支持

 

学无止境！