python基础知识

python

指令

print

输出字符以#相连，默认是空格相连

print(name,age,gender,sep='#')

print字符默认后面sep=''(空白字符)，end='\n'，所以多条print会自动换行

如果有多条print输出而不需要换行。

print('aaa',end='')
print('bbb',end='')

print输出多个变量
法一：加号相连

print('收件人是：'+person+'地址是'+address)

法二：格式化输出

print('收件人是:%s,地址是:%s'%(person,address))

转义字符

\r回车 \t制表符 \n换行

注：\r是打印头回到行首，人如果没有\n直接\r，这行会被覆盖

单引号不能套单引号，要转义字符

print('乔治说:\'想吃冰淇淋\'')

双引号可以套单引号，单引号可以套双引号

原样输出转义字符的方法

print('hello\py\\thon')

或

print(r'hello\py\thon')#r表示原样输出字符串的内容

引号

三引号可以在输出长的情况下保证样式输出,也可以用于多行注释。

print('''
你好
      你好
''')

类型转换

其他类型转为字符类型
str()

取整
int()

保留两位小数
%.2f

字符串的格式化输出

方法一 使用占位符

方法二 使用format

age=2
s='已经上'
message= '乔治{}岁，{}幼儿园'.format(age,s)
print(message)

id()

打印存储变量的地址

print(s1==s2)#比较的是内容
print(s1 is s2)#比较的是地址，且常量赋值如果一样为TRUE，input输入底层做了处理所以为FALSE

s1='abc'
s2="abc"#三引号占用的内存空间与单引号不同（前提：三引号的内容不在一行上）

整数对象池

python小整数对象池(数字[-5,256]，或字符串长度小于20)，这些整数对象是提前建立好的，不会垃圾回收的，
终端是每次执行一次，所以每次的大整数都重新创建，在pycharm中，每次运行是所有代码都加载都内存中，属于一个整体，但是在交互式编译器中，会重新创建内存。

money=20000
id(money)
salary=20000
id(salary)

continue与break

break:跳过整个for循环结构
continue:跳过下方的语句不执行，继续执行下一次的循环

Python编程从入门到实战[Eric Matthes]学习笔记

1大小写转换
name="hello world"
print(name.title())#单词的字母首字变大写
print(name.upper())#所有字母变大写
print(name.lower())#所有字母变小写
print(name.capitalize())#将字符串的第一个字母串转成大写的标识形式

2合并字符串+
first="ada"
last="love"
full=first+" "+last
print(full)

3制表符
print("full")
print("\tfull")

4用制表符和换行符将单行字符生成多列输出
print("languages:\n\tpython\n\tC\n\tjavascript")

5 剔除空格
lan='            python         '
print(lan)
print(lan.rstrip())#剔除后面空格
print(lan.lstrip())#剔除前面空格
print(lan.strip())#剔除两端空格

6乘方运算
两个乘号  3**2

7使用str()避免类型错误
age=2
message="happy "+str(age)+"birthday"

8列表
lan=['a','b','c','d']
print(lan)
print(lan[0])#索引
print(lan[0].title())
lan[0]='e'#修改
lan.append('f')#末尾添加新元素
lan.insert(0,'g')#在位置0添加元素
del lan[0]#删除元素（永远删除）

替换
replace(old,new [,max])
#把字符串中的str1替换成str2，如果max指定，则替换不超过max次

删除空格
replace(' ','')

查找
find(str,beg=0,end=len(string)
#检测str是否在字符串中，复入贡指定范围beg和end，则检查是否包含在指定范围内，如果包含则返回开始的索引值，否则返回-1，如果找到则返回位置
rfind()从右侧检测
index(str,beg=0,end=len(string))#跟find方法一样，只不过如果str不在字符串会报一个异常


print(lan[5:0:-1])#逆序取值
print(lan[::-3])#逆序隔三个取一个值

判断是否以什么开头结尾
startswitch()#开头判断
endswitch()#结尾判断
isalpha()#字母判断
isdigit()#数字判断

pop弹出元素
lan=['a','b','c','d']
a=lan.pop()
print(lan)#剩余元素放在lan中
print(a)#弹出元素存在a中

#弹出任何位置元素
lan=['a','b','c','d']
a=lan.pop(1)
print(a)#弹出元素存在a中


lan=['a','b','c','d']
gg='c'
lan.remove(gg)#知道值不知道位置，删除元素
print lan


排序
lan=['a','e','c','d']
lan.sort()#按字母排序
print(lan)
lan.sort(reverse=True)#反排
print(lan)
不影响原来列表排序，可以用sorted()


列表长度
len()

for循环中不缩进的代表只执行一次


9创建数字列表
for value in range(1,5):#打印第一个数到第四个数
	print(value)
	
创建列表 list(range(1,5))
步长 range(2,11,2)


10求列表里面数字的平方
for value in range(1,11):
    square.append(value**2)
print(square)

11切片
print(players[1:4])
#要输出离列表mowing相应距离的元素
players[-3:]

12 复制列表
a2=a1[:]
不同于赋值 ，改变一个列表不会改变复制的列表

13元组
与列表不同，元组不可改变，若要改变，需要重新定义元组
x=(4,6,8,5,9,7,2)
print(x[2:-3])#元组切片
print(max(x))#元组最大值
print(sum(x))
print(x.count(8))#元组中8元素的个数
print(x.index(8))#元组中8元素的下标

14字典
alien={'color':'green','points':5}
point=alien['points']
print("you just earned"+str(point)+" points")
#添加键值对
alien['x']=0
alien['y']=25
print(alien)
#修改键值对
alien['points']=6
print(alien)
#删除键值对
del alien['points']
print(alien)

dict1 = {'张三':100,'李四':100,'王五':100,'赵六':10}
result = dict1.pop('赵六'，'如果找不到，则返回此键')#pop根据key删除字典中的键值对，返回值是删除成功的键值对的值
print(result)
print(dict1)

dict1 = {'张三':100,'李四':100,'王五':100,'赵六':10}
result = dict1.popitem()#从末尾删除一个键值对
print(result)

dict1.clear()#清空字典
#遍历键值对
for key, value in alien.items():
    print("\nkey:"+key)
    print("value:"+str(value))
    
    
#遍历键
for name in alien.keys():#或者for name in alien():因为遍历字典时，默认遍历所有的键
    print(name.title())
	
favorite_languages={
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

friends=['phil','sarah']
for name in favorite_languages.keys():
    print(name.title())

    if name in friends:
        print("hi "+name.title()+
              ",I see your favorite language is"+
              favorite_languages[name].title()+"!")
			  
for name in sorted(favorite_languages.keys()):#按顺序遍历
for language in favorite_languages.values():#遍历值
for language in set(favorite_languages.values()):#剔除重复项遍历

15嵌套（在列表中存储字典）
alien_0={'color':'green','points':5}
alien_1={'color':'yellow','points':10}
alien_2={'color':'red','points':15}
aliens=[alien_0,alien_1,alien_2]
for alien in aliens:
    print(alien)
	
aliens=[]#空列表
#创建30个外星人
for alien_number in range(30):
    new_alien={'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)
#显示前五个外星人
for alien in aliens[:5]:
    print(alien)
print("...")
#显示创建了多少个外星人
print("Total number of aliens:"+str(len(aliens)))
for alien in aliens[0:3]:
    if alien['color']=='green':
        alien['color']='green'
        alien['speed'] = 'medium'
        alien['points'] = 10
    elif alien['color']=='yellow':
        alien['color'] = 'red'
        alien['speed'] = 'fast'
        alien['points'] = 10

16在字典中存储列表
#当在字典中将一个值关联到多个值时，都可以在字典中嵌套一个列表
favorite_languages={
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go'],
    'phil':['python','haskell'],
}
for name,languages in favorite_languages.items():
    print("\n"+name.title()+"'s favorite languages are:")
    for language in languages:
        print("\t"+language.title())		


17在字典中存储字典
#在字典中嵌套字典
users={
    'aeinstein':{
        'first':'albert',
        'last':'estin',
        'location':'princeton',
    },
    'mcurie':{
        'first':'marie',
        'last':'curie',
        'location':'paris',
    },
}
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())


18实参和形参
def get_formatted_name(first_name,last_name):
    full_name=first_name+' '+last_name
    return full_name.title()

while True:
    print("\nplease tell me your name")
    f_name=input("first name:")
    l_name=input("last name")
    formatted_name=get_formatted_name(f_name,l_name)
    print("\n hello,"+formatted_name+"!")
改进版（增加了退出）
def get_formatted_name(first_name,last_name):
    full_name=first_name+' '+last_name
    return full_name.title()

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
    if l_name=='q':
        break
    l_name=input("last name")
    formatted_name=get_formatted_name(f_name,l_name)
    print("\n hello,"+formatted_name+"!")
	
19 函数中修改列表
unprinted_designs=['iphone case','robot pendant','dodecashedron']
completed_models=[]
#模拟打印每个设计，直到没有未打印的设计为止
#打印每个设计后，都将其移到列表completed_models中
while unprinted_designs:
    current_design=unprinted_designs.pop()
    #模拟根据设计制作打印模型的过程
    print("printing model:"+current_design)
    completed_models.append(current_design)
#显示打印好的所有模型
print("\nthe following models have been printed")
for completed_model in completed_models:
    print(completed_models)
	
#编写两个函数来表达
def print_models(unprinted_designs,completed_models):
    while unprinted_designs:
        current_design=unprinted_designs.pop()
    #模拟根据设计制作打印模型的过程
        print("printing model:"+current_design)
        completed_models.append(current_design)
def show_completed_models(completed_models):
    print("\nthe following models have been printed")
    for completed_model in completed_models:
        print(completed_models)
unprinted_designs=['iphone case','robot pendant','dodecashedron']
completed_models=[]
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)


20创建函数副本
print_models(unprinted_designs[:],completed_models)#print_models()依然能完成工作，因为他获得的是所有未打印的设计的名称
#但它使用的是列表unprinted_designs的副本，而不是unprinted_designs本身

21传递任意数量的实参
def make_pizza(*toppings):
    print("\nmakeing a pizza with the following topping:")
    for topping in toppings:
        print("- "+topping)

make_pizza('prpperoni')
make_pizza('mushrooms','green peppers','extra cheese')

22使用位置实参和任意数量实参
#如果让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参放在最后，python先匹配位置实参和关键字实参，再将
#余下的实参都收集到最后一个形参中
如def make_pizza(size,*topping)#*topping代表元组

23将函数编写成能接受任意数量的键值对
def build_profile(first,last,**user_info):#允许提供名和姓，同时允许用户提供任意数量的名称-值对
#**user_info两个星号让python创建一个名为user_info的空字典，并将收到的名称-值对封装在这个字典中，
    profile={}#创建一个名为profile的空字典，用于存储用户简介
    profile['first_name']=first
    profile['last_name']=last#将名和姓加入字典中
    for key,value in user_info.items():#遍历user_info中键值对，并将键值对加入到字典profile中
        profile[key]=value
        return profile
user_profile=build_profile('albert','einstein',location='princeton',field='physics')#后两个是键值对
print(user_profile)


24类
#使用dog创建的每个实例都将存储名字和年龄，然后赋予每条小狗蹲下和打滚的能力
class dog():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def sit(self):
        print(self.name.title()+" is now sitting")
    def roll_over(self):
        print(self.name.title()+"rolled over!")

my_dog=dog('willie',6)
print("my dog's name is "+my_dog.name.title()+".")
print("my dog's is"+str(my_dog.age)+"years old")
my_dog.sit()
my_dog.roll_over()
#创建多个实例
my_dog=dog('will',6)
your_dog=dog('lucy',3)
print("my dog's name is"+my_dog.name.title()+".")
print("my dog is "+str(my_dog.age)+" years old.")

25继承
#继承 如果要编写的类是另一个现成类的特殊版本，可使用继承
class car():
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=0
    def get_descriptive_name(self):
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    def read_odometer(self):
        print("this car has"+str(self.odometer_reading)+" miles on it")
    def update_odometer(self,mileage):
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("you can't roll back on odometer!")
    def increment_odometer(self,miles):
        self.odometer_reading+=miles

class electriccar(car):
#电动汽车的独特之处
    def __init__(self,make,model,year):
    #初始化父类的属性
        super().__init__(make,model,year)#super特殊函数，将父类和子类关联起来，这行代码让python调用electriccar的父类的方法_init_()
my_tesla=electriccar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())


26给子类定义属性和方法
#让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法
#用代码模拟实物时，会发现自己给类添加的细节越来越多，属性和方法清单越来越长，在这种情况下，可能需要将类的一部分作为一个类提取出来
#例如，不断给electriccar添加细节时，会发现其中包含很多专门针对汽车电瓶的属性和方法，可以将这些属性和方法提取出来，昂到另一个名为battery的类中
#并将battery的实例作为electriccar类的一个属性
class car():
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=0
    def get_descriptive_name(self):
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    def read_odometer(self):
        print("this car has"+str(self.odometer_reading)+" miles on it")
    def update_odometer(self,mileage):
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("you can't roll back on odometer!")
    def increment_odometer(self,miles):
        self.odometer_reading+=miles

class battery():
    #一次模拟电动汽车店铺的简单尝试,没有继承任何类
    def __init__(self,battery_size=70):#除了self外，还定义了一个形参battery_size，这个形参是可选的，方法battery_size也移到了这个类中
        self.battery_size=battery_size
    def describe_battery(self):
        print("this car has a "+str(self.battery_size)+" -kwh battery.")
    def get_range(self):
        if self.battery_size==70:
            range=240
        elif  self.battery_size==85:
            range=270
        message="this car can go approximately"+str(range)
        message+="miles on a full charge."
        print(message)

class electriccar(car):
#电动汽车的独特之处
    def __init__(self,make,model,year):
    #初始化父类的属性
        super().__init__(make,model,year)#super特殊函数，将父类和子类关联起来，这行代码让python调用electriccar的父类的方法_init_()
        self.battery=battery()#让python创建了一个新的battery实例，并将该实例存储到属性self.battery中每当方法_init_()被调用时都将执行该操作
    #因此现在每个electrcar实例都将包含一个自动创建的battery实例

my_tesla=electriccar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()#在实例my_tesla中查找属性battery，并对该属性中的battery实例调用方法describe_battery()
my_tesla.battery.get_range()

判断输入的是否是图片

path=input('请选择文件')
p=path.rfind('\\')
filename=path[p+1:]
if filename.endswith('jpg') or filename.endswith('png')
	print('是图片，允许上传')
else:
	print('不是图片')

拼接
list=['a','b','c']
result='+'.join(list)
print(result)

找出最大值最小值
import random
random_list=[]
i=0
while i<10:
ran=random.randint(1,20)
if ran not in random_list:
random_list.append(ran)
i+=1
print(random_list)

找出最大数最小数

mvalue=random_list[0]
minvalue=random_list[0]
for value in random_list:
    if value > mvalue:
        mvalue=value
    if value < minvalue:
        mvalue=value
print('最大值是：',mvalue)

取出字符串中某些字母

s1="this is a test of python"
#统计字符串中s1出现的次数
count('s')
#取出test的表达式
s1[s1.find('test'):s1.find('test'+4)]


冒泡排序

myList = [6,9,10,8,7,1,5,4,3,2]
length = len(myList)
for i in range(0,length-1):
for j in range(0,length-1-i):
if myList[j] > myList[j+1]:
tmp = myList[j]
myList[j] = myList[j+1]
myList[j+1] = tmp
#或myList[j],myList[j+1]=myList[j+1],myList[j]

print(myList)

print(""10)
print(myList)

###拆包装包

t=(1,2,3,4,5,6)
a,*,b=t
print(a,b,)

x,*y=(4,6,8)#赋值装包
print(y)#以列表形式

print(*[4,6,8])#打印拆包