python的基础知识

python的基础知识
观看唐宇迪的Python基础课所做的笔记：

编译环境：

Python学习
基础开发
web开发
运维开发
机器学习
深度学习
计算机视觉与自然语言处理
数据挖掘
Spark大数据系列
大数据—>机器学习—> 深度学习
发展历程：
1989年 荷兰人 发明
2000年 Python2.0发布
2008年 Python3.0
数值运算：
加减乘除取余：

1+1
2

1-1
0

1*6
6

10/3
3.3333333333333335

10%3
1
平方：

2**3

---

10的N次方：2e2
200

---

赋值：
tan=3
print(tan)
输出类型：
tang=1.5
print(type(tang))
输入：
python的输入操作：

name=input()#按enter后，可以输入字符串
Michael
返回随机整数：
import random
a=random.randint(1,100)
print(a)

---

PS:
import random
print( random.randint(1,10) ) # 产生 1 到 10 的一个整数型随机数
print( random.random() ) # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) ) # 产生 1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice(‘tomorrow’) ) # 从序列中随机选取一个元素
print( random.randrange(1,100,2) ) # 生成从1到100的间隔为2的随机整数
类型转换：
int():字符，浮点转整型，浮点删除小数部分
float():字符，整型转浮点
str():整型，浮点转字符
计算顺序：
1，（）
2， **
3, */
4, ±
基本数值操作：

abs(15.6)#绝对值
15.6

round(15.6)#绝对值
16

max(1,2,3)#最大值
3

min(1,2,3)#最小值
1
字符串操作：
1，加法及乘法操作:

tan=“hello”+“world”
print(tan*3)
helloworldhelloworldhelloworld
2，长度：

tan=“hello”+“world”
len(tan)
11
3, 切分：

tang=“1 2 3 4 5”
tang.split()
[‘1’,‘2’,‘3’,‘4’,‘5’]

---

split()函数
语法：str.split(str="",num=string.count(str)[n])
参数说明：
str:表示为分隔符，默认为空格，但是不能为空(’’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]:表示选取第n个分片
注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略
eg:
string = “www.gziscas.com.cn”
1.以’.‘为分隔符
print(string.split(’.’))
[‘www’, ‘gziscas’, ‘com’, ‘cn’]
2.分割两次
print(string.split(’.’，2))
[‘www’, ‘gziscas’, ‘com.cn’]
3.分割两次，并取序列为1的项
print(string.split(’.’,2)[1])
gziscas
4.分割两次，并把分割后的三个部分保存到三个文件
u1, u2, u3 =string.split(’.’,2)
print(u1)—— www
print(u2)—— gziscas
print(u3) ——com.cn

---

4,拼合:
str.join(sequence)
5,替换：

tang=“hello python”
tang2=tang.replace(‘python’,‘world’)#先写选定的，再写替换它的
print(tang2)
‘hello world’
6,大小写：

tang=“hello python”
tang.upper#小写转大写
‘HELLO PYTHON’

tang=‘PYTHON’
tang.lower#大写转小写
‘hello world’

tang=’ hello python ’
tang.strip#去掉字符串两边的空格
‘hello python’

tang=’ hello python ’
tang.lstrip#去掉字符串左边的空格
'hello python ’

tang=’ hello python ’
tang.rstrip#去掉字符串以右边的空格
’ hello python’

‘{} {} {}’.format(“tang”,“yu”,’'di")#传参
‘tang yu di’

‘{2} {1} {0}’.format(“tang”,“yu”,’'di")#传参
‘di yu tang’

‘{tang} {yu} {di}’.format(“10”,“5”,’'1")#传参
‘10 5 1’

tang=‘tang yu di:’
b=450.0
c=789
result=’%s %f %d’ %(tang,b,c)#传参
result
tang yu di: 450 .000000 789
list
列表：
1，通过[]来创建一个list 结构；
2，里面可放任何类型，没有长度限制；

tang=[]
type(tang)
list

tang=1,2,3,4
tang
(1, 2, 3, 4)

tang=[‘1’,‘2’,‘3’,‘4’]
tang
[‘1’, ‘2’, ‘3’, ‘4’]

tang=list([1,2,3])
tang
[1, 2, 3]
list 操作：

tang=list([1,2,3])
len tang# 字节长
3

a=[123,456]
b=[‘zhu’,‘zhongchao’]
a+b #+直接拼接
[123, 456, ‘zhu’, ‘zhongchao’]

a=[123,456]
a*3 # 乘法
[123, 456, 123, 456, 123, 456]

tang=[‘apple’,‘apple’,‘banana’,‘banana’,‘apple’,‘apple’,‘apple’]
tang.count(‘apple’) #count：计数，统计出现了多少次
5
Python 字符串的索引:
0…5
string
-6…-1
索引:
获取特定偏移的元素:
字符串中第一个元素的偏移为 0
字符串中最后一个元素的偏移为-1
str[0] 获取第一个元素
str[-2] 获取倒数第二个元素

a=[123,456]
a[0]
123

a[1]
456

a[0:]
list核心操作：

tang=[‘apple’,‘apple’,‘banana’,‘banana’,‘apple’,‘apple’,‘9’]
tang.index(‘9’) #index :定位，找到想找的东西的索引
6

tang=[]
tang.append(‘tang’,‘yudi’)#append:每次增加一个元素，如果是list,相当于把一个listj加入
tang
[‘tang’,‘yudi’]

tang=[‘tang’,‘yudi’]
tang.insert(1,‘python’)#特定位置增加一个元素
tang
[‘tang’,‘python’,‘yudi’]

tang=[‘tang’,‘python’,‘yudi’]
tang.remove(‘python’)#删除元素
tang
[‘tang’,‘yudi’]

tang=[‘tang’,‘python’,‘yudi’]
tang.pop(1)# 弹出一个元素，索引为位置1
‘python’

tang=[1,8,5,7,4,3,2]
tang.sort()#从小到大排序,改变原始数据
tang
[1, 2, 3, 4, 5, 7, 8]

tang=[1,8,5,7,4,3,2]
tang2=tang.sorted(tang)#从小到大排序，不改变原始数据
tang2
[1, 2, 3, 4, 5, 7, 8]

tang=[‘chao’,‘zhong’,‘zhu’]
tang.reverse()#倒序输出
tang
[‘zhu’, ‘zhong’, ‘chao’]
字典操作：
字典结构

tang={}#字典结构的定义方式一
type（tang）
dict

tang=dict()
type (type)#字典结构的定义方式二
dict
字典结构的操作：
key-value 一个键key对应一个值value
赋值：

tang[‘first’]=123# 键为first,值为123
tang
{‘first’: 123}

tang[‘python’]=456
tang
{‘first’: 123, ‘python’: 456}
查值：

tang[‘python’]#通过键找到value值
456
改值

tang[‘python’]=789
tang
{‘first’: 123, ‘python’: 789}

tang={‘tang’:123,‘yu’:456,‘di’:789}
tang
{‘tang’: 123, ‘yu’: 456, ‘di’: 789}#没有顺序的结构
字典结构的核心操作：
里面传进什么结构都市可以的

tang_value=[1,2,3]
tang={}
tang[‘yudi’]=tang_value
tang[‘yudi2’]=3
tang[‘yudi3’]=‘zzc’
tang
{‘yudi’: [1, 2, 3], ‘yudi2’: 3, ‘yudi3’: ‘zzc’}
字典结构也可以和list一样嵌套：
tang={}

d1={‘tang’:123,‘yudi’:456}
d2={‘tang2’:789,‘yudi2’:789}
tang[‘test1’]=d1
tang[‘test2’]=d2
tang
{‘test1’: {‘tang’: 123, ‘yudi’: 456}, ‘test2’: {‘tang2’: 789, ‘yudi2’: 789}}
其他的定义方法：

tang=dict([(‘tang’,123),(‘yudi’,456)])
tang
{‘tang’: 123, ‘yudi’: 456}
get方法：

tang.get(‘tang’)
125

tang[‘tang’]
125

tang.get(‘fengzi’,‘meiyou’)#调出fengzi’,如果没有，则显示’meiyou’
‘meiyo’

tang.pop(‘tang’)#弹出了tang,则该字典结构还剩下 yudi
125

del.tang[‘yudi’]#删除干净yudi,则该字典结构什么也没剩下
{}
字典的更新：

tang={‘tang’:123,‘yudi’:456}
tang2={‘tang’:789,‘python’:888}
tang.update(tang2)#更新，保持原来字典不变，加东西，改东西
tang
{‘tang’: 789, ‘yudi’: 456, ‘python’: 888}
判定东西是否在字典当中：

‘tang’ in tang
true

‘zhu’ in tang
false
字典属性的调用：

tang.keys() #打印键值
dict_keys([‘tang’, ‘yudi’, ‘python’])

tang.values() #打印value值
dict_values([789, 456, 888])

tang.items() #打印键值和value值
dict_items([(‘tang’, 789), (‘yudi’, 456), (‘python’, 888)])
集合：保留不重复，唯一的元素

tang=[123,123,456,789]
tang=set(tang)#set（）定义集合
tang
{123, 456, 789}

tang=set([123,123,123,456,456,456,789])
tang
{123,456,789}

tang={1,1,1,3,4}#集合的定义二
tang
{1,3,4}
集合的操作：
并集：

a={1,2,3,4}
b={2,3,4,5}
a.union(b) #并集写法一
{1,2,3,4,5}

a={1,2,3,4}
b={2,3,4,5}
a|b#并集写法二
{1,2,3,4,5}
交集：

a={1,2,3,4}
b={2,3,4,5}
a.intersection(b)#交集写法一
{2,3,4}

a={1,2,3,4}
b={2,3,4,5}
a & b #交集写法二
{2,3,4}
检查集合的不同:

a={1,2,3,4}
b={2,3,4,5}
a.difference(b)#方法一
{1}

a={1,2,3,4}
b={2,3,4,5}
b.difference(a)
{5}

a={1,2,3,4}
b={2,3,4,5}
b-a#方法二
{5}

a={1,2,3,4}
b={2,3,4,5}
a-b
{1}
一个集合是否为令一个集合的子集：

a={1,2,3,4,5,6}
b={2,3,4}
b.issubset(a)#判定是否为子集的方法
True

a={1,2,3,4,5,6}
b={2,3,4}
a.issubset(b)
False

a={1,2,3}
a.add(4)
a
{1, 2, 3, 4}

a={1,2,3}
a.update([4,5,6])
a
{1,2,3,4,5,6}

a={1,2,3}
a.remove(1)
{2,3}

a={1,2,3}
a.pop()#一个一个地弹，（）不可以有任何参数，直到最终弹完
{2,3}
基本的赋值机制
数字大的赋值：数字一样，Id不一样
数字小的赋值：数字一样，Id一样

tang=1000
yudi=tang
id(tang)
1476644420968

tang=1000
yudi=tang
id(yudi)
1476644420968

tang Is yudi
True

tang=1
yudi=1
id(tang)
1365994560

tang=1
yudi=1
id(yudi)
1365994560
判定结构：
方法一;
tang=100
tang =100

tang=100
if tang>50:
print(‘ok’)#tab键，含4个空格
ok

tang =100
if tang>200:

print(‘ok’)#含4个空格,if内部结构
print(‘6a’)#不含空格，为外部结构
6a

tang=50
if tang>200:
print(‘200’)#含4个空格,if内部结构
elif tang<100:
print(‘100’)#含4个空格,elif内部结构,elif可写多个
else: #else只可写一个
print(‘100-200’)
100

tang={123,456,789}
if 123 in tang:
print(‘ok’)
ok

tang={‘tang’:123,‘yudi’:456}

if ‘tang’ in tang:
print (‘ok’)
ok
python 所有的控制结构都是用缩进完成的，没有分号
循环结构：
for, while

tang=0
while tang<10:
print(tang)
tang+=1
0
1
2
3
4
5
6
7
8
9

tangs=set([‘tang’,‘yu’,‘di’])
while tangs:
tang=tangs.pop()
print(tang)
di
yu
tang

tangs=set([‘tang’,‘yu’,‘di’])
for name in tangs:# for 循环一个一个遍历
print(name)
yu
di
tang

tang=100
for i in range(10):#从0到9取10个数
print(i)
0
1
2
3
4
5
6
7
8
9

tang={123,3454,3332,3223}
for i in range(len(tang))
print(tang[i])
123
3454
3332
3223
range函数：“
函数语法
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)

tang=[10,11,12,13,14,15]
for i in tang:
if i%2==0:
print(i)
else:
continue
print(i)
10
10
12
12
14
14

tang=[10,11,12,13,14,15]
for i in tang:
if i%2==0:
print(i)
else:
break
print(i)
10

高级模块：
函数：

a=10
b=20
a+b
30

#封装到函数
a=10
def print_value():
print(‘a=’,a)
print_value()
a=10

def add_ab(a,b):
print(a+b)
add_ab(3,5)
8

def add_ab(a,b):
return(a+b)
tang=add_ab(3,5)
tang
8

def add_ab(a=1,b=2):
return(a+b)
tang=add_ab()
tang
3

def add_ab(a=1,b=2):#可以自己设定默认值
return(a+b)
tang=add_ab(3,3):#也可以在传参的时候自己指定值
tang
6

def add_number(a,*args)#"args"函数接受不定个数的参数方法一
for i in args:
a+=i
return a
add_number(1,2,3,4)
10

def add_number2(a,**kwargs):#函数接受不定个数的参数方法二：传参只可以是键值对的格式
for arg,value in kwargs,.items():
print (arg,value)
add_number2(1,x=2,y=3)
x 2
y 3

def add_number(a,*args):#"args"函数接受不定个数的参数方法一
b=0
for i in args:
a+=i
b+=a
return a,b
add_number(1,2,3,4)
(10,19)

模块与包：

%%writefile tang.py #先写一个脚本文件
tang_v=10
def tang_add(tang_list)：
tang_sum=0
for i in range(len(tangt_list))：
tang_sum+=tang_list[i]
return tang_sum
tang_list=[1,2,3,4,5]
print (tang_add(tang_list))
Writing tang.py

%run tang.py #执行完此语句后,会Overwriting tang.py,再次shift+enter,执行成功
15

import tang#导入以前的工具包，只可以执行一次
15

print(tang.tang_v)#可以直接使用原来的变量
10

tang.tang_v=100#可以更改原来的变量
tang.tang_v
100

tang_list=[10,11,12]
tang.tang_add(tang_list)
33

import tang as tg #给函数变函数，依然可以执行
tg.tang_v
100

tg.tang_add(tang_list)
33

from tang import tang_v,tang_add
tang_v
100

tang_add(tang_list)
33

from tang import* #把包里所有东西度导进来
tang_v
100

tang_add(tang_list)
15

import os#导入操作系统中的命令
os.remove(‘tang.py’）
异常模块处理：

import math
for i in range(10):
input_number=input(‘write a number’)
if input_number==‘q’:
break
result=math.log(float(input_number))#log取得数必须>0
print(result)
write a number1
0
write a number0

---

抛出异常
write a number0

ValueError Traceback (most recent call last)
in ()
5 if input_number==‘q’:
6 break
----> 7 result=math.log(float(input_number))#log取得数必须>0
8 print(result)
ValueError: math domain error
解决方法：异常处理

import math
for i in range(10):
try：
input_number=input(‘write a number’)
if input_number==‘q’:
break
result=math.log(float(input_number))#log取得数必须>0
print(result)
except ValueError：
print(‘ValueError:input must>0’)
except ZeroDivisionError:
print(‘log(value) must!=0’)
except Exception:
print(‘uknow error’)
write a number0
ValueError:input must>0
write a number1
log(value) must!=0

class TangError(ValueError):
pass
cur_list=[‘tang’,‘yu’,‘di’]
while True:
cur_input=input()
if cur_input not in cur_list:
raise TangError(‘Invalid input:%s’%cur_input)
tang2
TangError: Invalid input:tang2
关键字：finally

try:
print(‘hello’)
finally: #是否遇见异常均需执行finally
print(finally)
hello
hehe-
文件操作：

%%writefile tang.txt #创立一个文件
hello python
tang yu di
jttqbuc
Writing tang.txt #在本地创建文件成功
读文件：

txt=open(’./data/tang.txt’)#从当前文件夹data下去寻找tang.txt文件
txt_read=txt.read() #读取全部行打印出来
print(txt)
hello python
tang yu di
jttqbuc

lines=txt.readlines()
print (type(lines))
print (lines)

[‘hello python\n’, ‘tang yu di\n’, ‘jttqbuc’]

for line in lines: #读取全部行一条一条打印出来
print(‘cur_line:’,line)
cur_line: hello python
cur_line: tang yu di
cur_line: jttqbuc

txt.close()#读写完毕，记得关闭文件
写文件：

txt=open(‘tang_write.txt’,‘w’)#w模式，是覆盖操作，原来的东西会去掉，新写进的东西会留下来
txt.write(’/n’)
txt.write(‘deiioufioure20e’)
txt.write(‘dfbweferhnfioegh’)
txt.close()
txt=open(‘tang_write.txt’,‘a’)#a模式，是追加操作，原来的东西会留下，新写进的东西会留下来
txt.write(’/n’)
txt.write(‘deiioufoure20e’)
txt.write(‘dfbeferhnfioegh’)
txt.close()

另外几种模式：
打开文件的模式有：
r ，只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则清空内容；】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
“+” 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+， 写读【可读，可写】
"b"表示以字节的方式操作
rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b

txt=open(‘tang_write.txt’,‘w’)
for i in range(100):
txt.write(str(i)+’\n’)
txt2=open(‘tang_write.txt’,‘r’)
print (txt2.read())
0
1
2
3
4
5

(此处省略)
*
99
100

txt=open(‘tang_write.txt’,‘w’)
try:
for i in range(100):
10/(i-50)
except Exception:
print(‘error:’,i)
finally: #finally 时一定要写关闭文件，否则文件可能会丢失
txt.close()
error:50
with 方法：相当于自动完成 try ,except ,finally,遇见错误，会直接把文件先关闭，执行完，会把文件关闭

with open(‘tang_write.txt’,‘w’)as f: #with打开，as取别名
f.write(‘jin tian tian qi bu hao’)
类：面向对象
构造函数格式：

class person（）
#构造方法
def__init__(self)：
特别注意：init前后均是两个“_”,self:在类的方法必须有个额外的第一个参数self，
但是在调用这个方法的时候不必为这个方法赋值，self代指对象本身

print（“构造函数被执行了！”）

p1=person()
构造函数被执行了！
#构造people 类

class people:
‘帮助信息：XXXX’
#所有的实力均共享
number=100
#构造函数，初始化方法，当创建一个类时，首先调用它
def init(self,name,age):#类的初始化方法，，，前后均是两个“”
self.name=name
self.age=age
def display(self):
print(‘number:’,people.number)
def display_name(self):
print(self.name)
people.doc#前后均是两个“”#打印帮助信息栏
‘帮助信息：XXXX’ #‘类文档字符串’

p1=people(‘tangyudi’,30)
p2=people(‘python’,40)
p1.name
‘tangyudi’

p2.name
‘python’

p1.display()
number=100

p2.display()
number=100

p2.name=‘hello’ #对于对象中的属性，可以进行修改值
p2.name
‘hello’

del p2.name
hasattr(p1,‘name’)#判断对象是否具有对应的属性，输出bool类型 ， hasattr(object,name)，括号里的name指对象的属性名字
True

hasattr(p1,‘sex’)
False

getattr(p1,‘name’)#获取对象的属性或方法 ， getattr(object,name[,default])，括号里的 name指对象的属性名字
‘tangyudi’

setattr(p2,‘name’,‘yuditang’)#给对象的属性赋值，若属性不存在，先创建再赋值 ， setattr(object,name.values)，括号里的name指对象的属性名字
p2.name
‘yuditang’

delattr(p1,‘name’)#删除对象的属性 delattr(object,'name)括号里的name指对象的属性名字
p1.name
AttributeError
类的属性操作

print(people.doc)#类的文档字符串
print(people.name)#类的名字
print(people.module)#类的定义所在的模块
print(people.bases)#类的父类构成的元素
print(people.dict)#类的整体组成是字典
帮助信息：XXXX
people
main
(,)
{‘module’: ‘main’, ‘doc’: ‘帮助信息：XXXX’,
‘number’: 100, ‘init’: init at 0x0000021E1F157C80>,
‘display’: ,
‘display_name’: ,
‘dict’: dict’ of ‘people’ objects>,
‘weakref’: weakref’ of ‘people’ objects>}
类的继承：
在python中继承中的一些特点：
1、如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法。
2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

class Parent: # 类的继承,定义一个父类
number=100
def init(self):
print(‘调用父类构造函数’)
def parentM(self):
print(‘调用父类方法’)
def setAttr(self,attr):
Parent.parentAttr=attr
def getAttr(self):
print(‘父类属性：’,Parent.parentAttr)
def newM(self):
print(‘父类中要被重写的方法’)

class child (Parent):#定义一个子类
def init(self):
print(‘调用子类构造函数’)
def childM(self):
print(‘调用子类方法’)
def newM(self):
print(‘子改掉的方法’)
c=child()
c.childM()
c.parentM()
c.setAttr(10)
c.getAttr()
c.newM()
调用子类构造函数
调用子类方法
调用父类方法
父类属性： 10
子改掉的方法
时间的运用：

import time
print(time.time())
print(time.localtime(time.time()))
1536820305.2141092#时间戳，从1970年1月1日开始到现在经历了多少时间
time.struct_time(tm_year=2018, tm_mon=9,
tm_mday=13, tm_hour=14, tm_min=34, tm_sec=35,
tm_wday=3, tm_yday=256, tm_isdst=0)

print(time.asctime(time.localtime(time.time())))#打印标准格式的当前时间
Thu Sep 13 14:39:19 2018

print(time.strftime(’%Y-%m-%d %H:%M:%S’,time.localtime()))#打印自定义格式的当前时间
2018-09-13 14:42:43

import calendar
print (calendar.month(2018,9))#打印一个月的日历

September 2018
Mo Tu We Th Fr Sa Su
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
help() 函数用于查看函数或模块用途的详细说明。
语法：help([object])

print(help(calendar.month))#使用help 函数查询某个函数如何使用
习题练习：
1，有四个数字1，2，3，4，能组成多少个互不相同而且无重复数字的三位数？

for i in range(1,5):
for j in range(1,5):
for k in range(1,5):#取1-4，取不到5，左闭右开
if(i!=k) and (i!=j) and(j!=k):
print(i,j,k)

1 2 3
1 2 4
1 3 2
1 3 4
1 4 2
1 4 3
2 1 3
2 1 4
2 3 1
2 3 4
2 4 1
2 4 3
3 1 2
3 1 4
3 2 1
3 2 4
3 4 1
3 4 2
4 1 2
4 1 3
4 2 1
4 2 3
4 3 1
4 3 2

企业发放的奖金根据利润提成，利润（I）低于或等于10万元时，奖金可提10%，利润高于10万元，低于20万元时，低于10万元部分按10%提成，高于10万元部分可提成7.5%，
20万到40万之间时，高于20万部分，可提成5%；40万到60万之间，高于40万部分，可提成3%，60万到100万之间，高于60万部分，可提成1.5%，高于100万时，
超过100万部分按1%提成，当键盘输入当月利润I，求应发放奖金总数。

i=int(input(‘输入你的利润值：’))
arr=[1000000,600000,400000,200000,100000,0]
rat=[0.01,0.015,0.03,0.05,0.075,0.1]
result=0
for idx in range(0,6):
if i>arr[idx]:
result+=(i-arr[idx])*rat[idx]
i=arr[idx]
print(result)
输入你的利润值：2000000
49500.0
输入三个整数，x,y,z 把三个数从小到大输出：

my_list=[]
for i in range(3): #循环输入3个数 range是生成一个序列 为了for循环使用的
x=int(input(‘input:’))
my_list.append(x)
my_list.sort()#也可以写成：从小到大：my_list(reverse=False)/从大到小my_list(reverse=True) 默认为False
my_list
input:123
input:456
input:111
Out[1]:
[111, 123, 456]
4,将一个列表的数据复制到另一个列表中

a=[1,2,3]
b=a[:]
b
[1,2,3]
5，暂停输入一秒，并格式化当前时间，使用time 模块的sleep 函数。

import time
print(time.strftime(’%Y-%m-%d- %H:%M:%S’,time.localtime(time.time())))
time.sleep(1)
print(time.strftime(’%Y-%m-%d- %H:%M:%S’,time.localtime(time.time())))
time.sleep(2)
print(time.strftime(’%Y-%m-%d- %H:%M:%S’,time.localtime(time.time())))
2018-09-13- 20:16:00
2018-09-13- 20:16:01
2018-09-13- 20:16:03
6,打印所有的"水仙花数",所谓的"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水仙花数”，因为153=1³⁺⁵3+3^3.

for x in range(1,10):
for y in range(0,10):
for z in range(0,10):
s1=x100+y10+z
s2=pow(x,3)+pow(y,3)+pow(z,3) # 幂函数格式pow(object,value)
if s1==s2:
print(s1)
153
370
371
407
7,输入一行字符，分别统计出英文字母，空格，数字，和其他字符的个数。

s=input(‘input’)
letter=0
space=0
digit=0
others=0
for c in s:
if c.isalpha():
letter +=1
elif c.isspace():
space+=1
elif c.isdigit():
digit+=1
else:
others+=1
print(‘char=%d,space=%d,digit=%d,others=%d’%(letter,space,digit,others))
input1245566sdaaedw^T&& *()
char=8,space=4,digit=7,others=7
8,一球从100米高空自由落下，每次反弹后返回原来高度的一半，再落下，求它第10次反弹多高？

h=100#总高度
time=10#次数
height=[]#反弹高度
for i in range(2,time+1):
h/=2
height.append(h)#append:给列表末尾加一个数据项
print(‘第十次高度：’)
print(min(height)/2)
print(‘总弹的高度：’)
print(sum(height)*2+100)
第十次高度：
0.09765625
总弹的高度：
299.609375

9，两个3行3列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵

X= [[1,2,3],
[2,4,6],
[7,8,9]
]

Y= [[10,2,3],
[4,50,6],
[7,8,90]
]
Z= [[0,0,0],
[0,0,0],
[0,0,0]
]
for i in range(3):
for j in range(3):
Z[i][j]=X[i][j]+Y[i][j]
for z in Z:
print(z)
[11, 4, 6]
[6, 54, 12]
[14, 16, 99]
10，匿名函数求和
匿名函数：指定一个关键字，说它是匿名函数

sum_value=lambda x,y:x+y#关键字：lambda
print(sum_value(1,2))
3
11，查找字符串的位置

s1=‘awsedcdfwsc’
s2=‘ed’
print(s1.find(s2))
3
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，
则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
语法：find()方法语法：
str.find(str, beg=0, end=len(string))
参数
str – 指定检索的字符串
beg – 开始索引，默认为0。
end – 结束索引，默认为字符串的长度。
12,在字典中找到年龄最大的人，并输出

people={‘laowang’:40,‘tyudi’:30,‘zsng’:45}
m=‘tyudi’
for key in people.keys():
if people[m] m=key
print(m,people[m])
45
13，列表转化为字典

k=[‘tang’,‘yudi’]
v=[123,456]
print(dict([k,v]))
{‘tang’: ‘yudi’, 123: 456}
14，从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘“test”中保存

f=open(‘test.txt’,‘w’)
s=input(‘输入一个串串’)
s=s.upper()
f.write(s)
f.close()

f=open(‘test.txt’,‘r’)
print(f.read())
f.close()
输入一个串串abg
ABG