目录
趁着暑假花了几天的时间简单地学了一遍python的基础知识，
虽然只用它的高精但是基础的还是要学一下的选用的教材是《python编程从入门到实践》，很好的一本书，简单易懂python是真的简单，C++天下第一
python的优点在于自带高精，函数库非常丰富。简单易懂，不像C++必须从主函数开始调用，python任何地方都算，没有主函数main(),随意写，遍地开花
1.实现一行输入多个数字，用空格隔开
a,b,c,d=map(int,input().split(' '))#split()默认以空格隔开
print(a,b,c,d)
print(type(a))
输入：
1 2 3 4
输出：
1 2 3 4
<class 'int'>
2.实现一行输入多个单词，用","隔开
str1,str2,str3=map(str,input().split(','))
print(str1,str2,str3)
print(type(str1))
输入：
aaa,bbb,ccc
输出：
aaa bbb ccc
<class 'str'>
3.列表
（类似数组—什么都能同时存的数组）
a=[]
s='11'
#强制转换
s=int(s)
print(s)
#列表插入元素
a.insert(0,1)
a.insert(1,2)
a.insert(3,0)
print(a)
#列表翻转
a.reverse()
print(a)
#列表长度
print(len(a))
4.for循环
在同一行缩进里相当于是一个大括号里同时执行
for ans in a:
print(ans)
print(a)
#range函数遍历数，相当于for(int i=1;i<10;i++)i相当于下面的val
for val in range(1,10):
print(val)
#10到90（从0开始100结束不包括100（for(int i=0;i<100;i+=10)cout<<i<<endl;）
susm=list(range(0,100,10))#将数字列表转换成列表list直接赋值给新列表
for tmp in susm:
print(tmp)
susm=[]
for t in range(1,11):
susm.append(t**2)
print(susm)
#min函数
print(min(susm))
#max函数
print(max(susm))
#sum函数求和
print(sum(susm))
5.切片
qq=[tt*2+1 for tt in range(1,11)]
print(qq)
print(qq)
#切片
print(qq[-3:])
#从头到尾
my_qq=qq[:]
#列表里什么类型都可以放
my_qq.append('qq')
print(my_qq)
for t in qq:
if t==5:
print("ok")
elif t!=9and t<=13:#&&
print("ok")
elif t==3or t==21:#||
print("ok")
else :
print(t)
6.二维列表
lists=[[]for i in range(3)]
lists[0].append(3)
lists[1].append(4)
lists[2].append(5)
print(lists)
#用python实现二维数组
myList = [([0] * 3) for i in range(4)]
myList[0][1]=1
myList[1][1]=666
print(myList)
7.元组
就是const 数组，不能修改元素，但是可以直接给这个元组的变量再赋值，重新定义这个元组以达到修改的目的
yuanzu= (100, 200)
for tmp in yuanzu:
print(tmp)
if 19 in my_qq:
print("yes")
if 666666 not in my_qq:
print("666666 is not in my_qq")
tt=[]
#判断列表是否为空
if tt:
print("非空")
else:
print("空的")
8.字典
类似C++中的map<string,string>
my_house={'color':'blue','value':10000000.5}
#可以是字符串也可以是int double（键必须加''引号）python中''与""一样
my_house['color']='red'
#可以直接赋值
print(my_house['color'])
print(my_house['value'])
money=my_house['value']
print('I have'+' '+str(money)+' !')
#字典是动态的结构，可以随时赋值
my_house['location']='china'
print(my_house)#注意字典中键—值对的排列顺序与添加顺序不一定相同，python只关心键与值之间的关联关系
my_house['value']+=1003#和C++差不多也可以+=
print(my_house['value'])
#删除键—值对
del my_house['color']
print(my_house)#永远删除
favorite_languages= {
'meng':'c++','liu':'java',#注意每个键值对中间都有冒号:后面都有逗号,
'yang':'python','geng':'c++'
}
print(favorite_languages)
s=favorite_languages['meng']+' 天下第一 ！'
print(s)
#遍历字典的全部键值对
for key,val in favorite_languages.items():
print("key:"+key)
print("value:"+val)
#遍历字典的全部键
for k in favorite_languages.keys():
print("key:"+k)
frinds=['liu','yang']
#遍历字典的全部键,此写法与上面的效果一模一样
for k in favorite_languages:
print(k)
if k in frinds:
print("oh my god "+k+" !!您tql!!!")
#xxx.keys()返回的是一个列表，所以可以有下面的操作
if 'xishen' not in favorite_languages.keys():
print("xishen tql")
#sorted()排序按字典序排序
for name in sorted(favorite_languages.keys()):
print(name.title() + " thank you !!% % %")
#遍历字典中的所有的值
for val in favorite_languages.values():
print(val)
set容器
类似C++里的set，自动去重
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
for val in set(favorite_languages.values()):
print(val)
9.嵌套
字典列表——列表里嵌套字典
aliens = []
for i in range(0,30):
new_aliens={'color':'green','point':5,'speed':'slow'}
aliens.append(new_aliens)
if i<3:
aliens[i]['color']='yellow'
aliens[i]['point']=10
aliens[i]['speed']='medium'#跟c++中的map差不多支持直接下标访问
aliens[i]['extra']='money+10'#也可以直接添加新键值对
for alien in aliens[0:5]:
print(alien)
print("---------------------------------------")
字典列表——字典里面嵌套列表
pizza={
'crust':'thick',
'toppings':['mushrooms','bacon','extra cheese'],
}
for topping in pizza['toppings']:
print("\t"+topping)
language={
'meng':['c++','python'],
'yang':['c++'],
}
for name,langu in language.items():
print('\n'+name.title()+"'s favorite language are")
for i in langu:
print('\t',i.title())
字典字典——字典中嵌套字典不就是结构体嘛struct
users = {
'dalao' : {
'first' : 'yang',
'last' : 'niubi',
'location':'hubei',
},
'caiji':{
'first':'meng',
'last':'juruo',
'location':'henan',
},
}
for username,user_info in users.items():
print("\nUsername: "+username)
full_name=user_info['first']+" "+user_info['last']
location=user_info['location']
print("\tFull name: "+full_name.title())
print("\tLocation: "+location.title())
10.input()函数
tmp="hello,my friend"
tmp+="\nplease say something,and i will repeat it back to you : "
message=input(tmp)#可以直接在input()里加一些东西作为提示词
print(message)
11.while语句
cnt=0
while cnt<=3 :
print(cnt)
cnt+=1 #python 里没有cnt++
#break的使用
while cnt <=100:
cnt+=1
if cnt%2==0:
continue
print(cnt)
if cnt ==25:
break
users=['meng','long','yang','long']
confirmed_users=[]
while users:
#while(users)只要users内有元素就不停止
current_user=users.pop()
print(current_user)
confirmed_users.append(current_user)
for i in confirmed_users:
print("confirmed user: "+i)
users = ['meng', 'long', 'yang', 'long']
print(users)
while 'long' in users:
users.remove('long')
print(users)
12.通过输入来填充字典
date={}
flag=True
while flag:
name=input("\nyour name:")
language=input("your favorite")
date[name]=language
repeat=input("do you want to continue?(yes/no)")
if repeat == 'no':
flag=False
print("------------------")
for name,language in date.items():
print(name+" like "+language+".")
13.函数
跟C++一样必须先定义函数再调用,同一个函数名可以重复定义，并及时使用，因为后一个定义的会覆盖前一个，并不会像函数重载那样自动识别
位置实参
必须严格按照形参位置来安排实参位置
def greet_user(name):
"""显示简单的问候语"""
print("hello ! "+name.title()+' ! ')
greet_user("meng")
""" 多行注释==/* */ 1 """
关键字实参
def tql(name,score):
score+=50
print(name+str(score)+'分'+" tql"+ ' AK全场 ！' )
tql(score=50,name='dongge')#关键字实参，可以不按顺序
def tql():
print("ok")
tql()
形参的默认值
def pet(pet_name,species='dog'):
print("my "+species+"'s name is "+pet_name)
pet('wangcai')#位置实参，按顺序
pet('wangwang','cat')
pet(pet_name='ritian')
pet(species='bear',pet_name='miaomiao')
返回值
#可选实参
def total_name(first_name,last_name,middle_name=''):#令这个可选形参为空字符串并放到最后
if middle_name:#字符串可以直接if判空
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
full_name=first_name+' '+last_name
return full_name
name=total_name('meng','yu')
print(name)
name=total_name('meng','yu','fan')
print(name)
#返回字典
def build_person(first_name,last_name,age=''):#必须有冒号! ':'
person={'first name':first_name,'last name':last_name}
if age:
person['age']=age
return person
caiji=build_person('meng','fanyu',age=20)
print(caiji)
while True:
print("\nPlease tell me your name")
print("(enter 'q' at any time to quit)")
f_name=input("first name: ")
if f_name=='q':
break
l_name=input("last name: ")
if l_name=='q':
break
formatted_name=total_name(f_name,l_name)
print("hello ,"+formatted_name+" !")
传递列表,任何形式的实参都可以传递过来
def name(names):
print(names)
namess={'123':11,'meng':666}
name(namess)
base_name=[]
def greet_users(names):
while names:
i=names.pop()#形参可以直接改变实参
print(i)
base_name.append(i)
name=['meng','wang','yang']
greet_users(name[:])#如果用(name)会被改变，但是加上[:]之后，就不会被改变
print(base_name)
print(name)
14.模块
将函数存到模块中
模块是扩展名为.py的文件
def makes(size,*toppings):
print("meka a "+str(size)+" -inch pizza")
print("pizza with following toppings")
for i in toppings:
print("-"+i)
pizza.py文件
#导入模块：
import pizza
#导入具体的函数：
from pizza inport makes
#导入具体函数并用as来指定别名：
from pizza import makes as mp
mp(16,'musgroom')
#用as给模块指定别名
import pizza as p
#导入模块的所有函数
#星号*运算符可以让python导入模块中的所有函数
from pizza import *
15.类，创建和使用类
class Dog():
#方法，方法_init_()是一个特殊的方法，每当你根据Dog来创建类的时候python就会自动调用运行它
#类中每个属性都必须初始化
def __init__(self,name,age):
"""初始化属性name 和 age"""
self.name=name
self.age=age
self.money=0
#给属性指定默认值
#可以设置默认值，这样就不用在形参列表里传入这个属性即可直接调用，如上面的那个money
def sit(self):
"""模仿小狗被命令蹲下的操作"""
print(self.name.title()+"is now sitting ")
def roll(self):
"""模仿小狗被命令时打滚"""
print(self.name.title()+"rolled over!")
def make_a_profit(self,up,down):
if down>0:
print("我怎么赔钱了")
self.money-=down
else :
print("我赚钱啦")
self.money+=up
def feed_dog(self):
print("ok,my dog is fulled")
my_dog=Dog('喵喵',6)
your_dog=Dog('旺财',1)
print("my dog 's name is " +my_dog.name.title()+".")
print("my dog is "+str(my_dog.age)+"years old .")
my_dog.sit()
my_dog.roll()
my_dog.feed_dog()
your_dog.sit()
print("your money:"+str(your_dog.money))
#修改属性的值：
#1.直接修改：
my_dog.money=1000000000
print("my money : "+str(my_dog.money)+"人民币")
#2.通过方法(函数)修改属性里的值
#在类里编写一个函数即可，然后调用
my_dog.make_a_profit(666666,0)
print("my money : "+str(my_dog.money)+"人民币")
16.类的继承
#一个类继承另一个类时，它将自动获得了另一个类的全部属性和方法（python里的方法，其实就是成员函数）
#原有的类被称为父类，而新类被称为子类，子类继承了父类的所有发属性和方法，并且可以定义自己的属性和方法
class robot_dog(Dog):
#需要用super函数来帮助子类获得父类的属性和方法
def __init__(self,name,age):
super(robot_dog, self).__init__(name,age)#这个是继承用的，新属性不用在这儿写，写到下面就好
self.electric_quantity=100
#类的属性也可以用别的类来初始化例如：self.battery=Battery()（#具体的Battery类懒得写了）
#这样初始化的属性，这个类也可以用Battery类的方法
#添加新方法
def describe_battery(self):
print("my robot dog's battery is "+str(self.electric_quantity)+"% . ")
#改写父类的方法
def feed_dog(self):
print("electric dog does not need to feed !")
my_robot_dog=robot_dog('小蜗',100)
#子类获得之后可以直接调用父类的方法
my_robot_dog.make_a_profit(666666666666,0)
print(str(my_robot_dog.money))
my_robot_dog.describe_battery()
my_robot_dog.feed_dog()
17.导入类：
from MY_Dog import Dog#MY_Dog 是文件的拓展名MY_Dog.py
#其实就是把一个模块里放入一些类（一个或多个），然后正常地调用就好
from MY_Dog import Dog , robot_dog
import MY_Dog
from MY_Dog import *
#在一个模板中导入另一个模板#MY_Dog.py和Robot_Dog.py
from MY_Dog import Dog
from Robot_Dog import robot_dog
#从collections中导入类OrderedDict，调用它，即创建了一个记录了键值对的字典
from collections import OrderedDict
i=OrderedDict()
i['meng']='C++'
i['yang']='python'
i['wang']='C#'
for name,language in i.items():
print(name.title()+"'s favorite language is "+language.title()+".")
更多python请看廖雪峰Python3教程.
ψ(｀∇´)ψ
京公网安备 11010502036488号