Python超详细基础入门
- 一、变量和简单数据类型
- （一）修改字符串大小写
- （二）制表符和换行符
- （三）删除空白
- （四）数
- 二、列表
- （一）列表定义
- （二）修改、添加和删除元素
- （三）组织列表
- 三、操作列表
- （一）遍历整个列表
- （二）创建数值列表
- （三）使用列表的一部分
- （四）元组
- 四、if语句
- （一）if语句
- (二）条件测试
- 五、字典
- （一）使用字典
- （二）遍历字典
- （三）嵌套
- 六、用户输入和while循环
- （一）函数input（）
- （二）使用while循环
- （三）使用while循环处理列表和字典
- 七、函数
- （一）创建函数
- （二）导入函数
- 八、类
- （一）创建和使用类
- （二）继承
一、变量和简单数据类型
- 变量的命名只能包含字母、下划线和数字，数字不能打头
- f字符串：f是format的简写，python会把花括号内的变量变换为其值
name=" yu xiaohui "
print(f"Hello {name.title().strip()},would you like to learn some Python today?")（一）修改字符串大小写
- title():将每个单词的首字母改为大写
- upper():将字符串全部改为大写
- lower():将字符串全部改为小写
name="li wenhao"
print(name.title())
print(name.upper())
print(name.lower())（二）制表符和换行符
- \t:制表符
- \n:换行符
print("languages:\n\tPython\n\tC\n\tJava")（三）删除空白
- rstrip()：删除字符串末尾空白
- lstrip()：删除字符串开头空白
- strip()：删除字符串两边空白
name=" Albert Einstein "
print(name.lstrip())
print(name.rstrip())
print(name.strip())（四）数
整数大家都知道，浮点数其实就是小数点可以出现在数的任意位置。
- 当数值很大时，用下划线将数分组，使其更清晰易读，注意python并不会打印下划线
number=1000_000_000
print(number)- 同时给多个变量赋值
x,y,z=0,1,2二、列表
（一）列表定义
[]：表示列表，并用逗号分隔其中的元素，索引从0而不是1开始
fruits=['apple','orange','banana','pear']
print(fruits) #访问列表
print(fruits[0]) #访问列表第一个元素（二）修改、添加和删除元素
- lst.append()：在列表尾部添加元素
fruits=['apple','orange','banana','pear']
fruits.append('strawberry')
print(fruits)- lst.insert(idx,val)：在列表的任意位置idx添加元素val
fruits=['apple','orange','banana','pear']
fruits.insert(0,'strawberry') #把'strawberry'添加到第一个元素
print(fruits)- del lst[idx]：删除列表中的元素
fruits=['apple','orange','banana','pear']
del fruits[0] #删除第一个元素
print(fruits)- lst.pop(idx)：删除idx位置上的元素并返回，默认为结尾
fruits=['apple','orange','banana','pear']
fruit=fruits.pop([1]) #删除列表的第二个元素，并返回第二个元素给fruit变量
print(fruit)
print(fruits)- lst.remove(val)：找到元素val在该列表的位置，并删除
fruits=['apple','orange','banana','pear']
fruit='banana'
fruit=fruits.remove(fruit)
print(fruits)为了能更好的理解这几条语句，编写了一个大合集
party_participator=['Monica','Phoebe','Ross','Chandler','Joey']
party_participator.insert(0,'Rachel')
party_participator.append('Janice')
del party_participator[1]
party_participator.remove('Chandler')
name=party_participator.pop(-2)
print(party_participator)（三）组织列表
- lst.sort()：对列表永久排序
- sorted(lst)：对列表临时排序
- lst.reverse()：倒着打印列表
- len(lst)：列表长度
- set()：找出列表中独一无二的元素构成一个字典（{}表示）
fruits=['apple','orange','banana','pear']
print(sorted(fruits)) #临时排序
print(fruits)
fruits.sort() #永久排序
print(fruits)
fruits.reverse() #顺序颠倒
print(fruits)
print(len(fruits))三、操作列表
（一）遍历整个列表
使用for循环，从列表中从前往后依次取出一个元素赋给fruit，执行相同的操作，注意缩进：
fruits=['apple','orange','banana','pear']
for fruit in fruits：
print(fruit)（二）创建数值列表
- 使用range()函数，从开始的数到结束的数的前一个数
for value in range(1,5) #从1到4
print(value)- 创建数字列表，list()将结果转化为列表
numbers=list(range(1,6)) #从1到5
print(numbers)numbers=list(range(1,10,2)) #加入步长，列表相邻的数值相差2
print(numbers)- 对数字列表进行简单的统计运算
numbers=[1,2,3,4,5,6,7,8,9,10]
print(min(numbers)) #列表最小值
print(max(numbers)) #列表最大值
print(sum(numbers)) #对列表元素求和- 列表解析：将for循环和创建新元素的代码合并成一行
squares=[value**2 for value in range(1,11)]
print(squares)（三）使用列表的一部分
- 切片
fruits=['apple','orange','banana','pear']
print(fruits[0:3]) #该切片包含从0到2三个元素
for fruit in fruits[0:3]:
print(fruit)- 复制列表：[:]在新列表上进行的操作对原列表无影响
fruits=['apple','orange','banana','pear']
copy_fruits=fruits[:]
print(copy_fruits)（四）元组
- 使用圆括号而非列表使用的方括号
- 元组的元素不可修改
numbers=(1,2,3,4,5)
for number in numbers:
print(number)四、if语句
（一）if语句
- if-else：要么执行if语句，要么执行else语句
- if-elif-else:多个条件测试
(二）条件测试
- ==：判断两个值是否相等
- !=：判断两个值是否不等
- < >= <= >：数值比较
- and or ：检查多个比较
- 布尔表达式：结果要么为True，要么为False
fruits=['apple','orange','banana','pear']
fruit='apple'
if fruit in fruits:
print("Get it!")
else :
print("Error!")
if fruit == 'apple':
print("fruit is apple")
elif fruit == 'orange':
print("fruit is orange")
else:
print("Cannot find it!")五、字典
（一）使用字典
键和值之间用冒号分割，而键值对之间用逗号分隔
- 访问字典
alien={'color':'green','point':5}
print(alien['color'])- 添加键值对
alien={'color':'green','point':5}
alien['weight']=80
alien['height']=200
print(alien)- 修改字典中的值
alien={'color':'green','point':5}
alien['color']='yellow'
print(alien['color'])- 删除键值对
alien={'color':'green','point':5}
del alien['color']
print(alien)- 使用get()来访问值，如果字典中有键’height’，则返回对应的值，否则返回’No point value assigned.‘
alien={'color':'green','point':5}
value=alien.get('height','No point value assigned.')
print(value)- 更清晰明了的字典，注意锁进和逗号
favorite_languages={
'Bob':'C',
'Alice':'Python',
'Joey':'Java',
}（二）遍历字典
- 遍历所有键值对items()
languages={
'Bob':'Python',
'Alice':'C',
'David':'Java'
}
for name,language in languages.items(): #items()返回一个键值对列表
print(f"\nname:{name}")
print(f"language:{language}")- 遍历所有键keys()
languages={
'Bob':'Python',
'Alice':'C',
'David':'Java'
}
for name in languages.keys(): #返回所有的键
print(name.title())- 遍历所有值values()
languages={
'Bob':'Python',
'Alice':'C',
'David':'Java'
}
for language in languages.values(): #返回所有的值
print(language)（三）嵌套
- 存储字典的列表：每个字典代表一个人的所有信息
aliens=[] #创建列表
for number in range(30): #批量创建字典
new_alien={'color':'green','points':5,'speed':'slow'}
aliens.append(new_alien)
for alien in aliens[:3]: #批量修改字典
if alien['color']=='green':
alien['color']='yellow'
alien['points']=10
alien['speed']='medium'
for alien in aliens[:6]: #展示前六个
print(alien)- 存储列表的字典：每个键对应多个值
pizza={
'crust':'thick',
'toppings':['mushrooms','extra cheese'],
}
print(pizza['crust'])
print(pizza['toppings'])六、用户输入和while循环
（一）函数input（）
- input()让程序暂停运行，等待用户输入一些文本
- int()获取数值输入
- 求模运算符%，将两个数相除并返回余数
height=input("How tall are you?")
height=int(height)
if(height>160):
print("\nYou are enough height to ride!")
else:
print("\nYou didn't reach the height to ride!")（二）使用while循环
- for循环用于针对集合中的每个元素都执行一个代码块，而while循环则不断运行，直到指定的条件不再满足
number=1
while number<=5:
print(number)
number+=1- break:不再执行余下的代码并退出整个循环
sentence='Please enter the name of a city you have visited'
sentence+='\n(Enter "quit" when you want to end):'
while True:
city=input(sentence)
if city=='quit':
break
else:
print(f"I'd like to go to {city.title()}")- continue:不再执行余下的代码并返回至循环开头
number=0
while number<10:
number+=1
if number%2==0:
continue
print(number)（三）使用while循环处理列表和字典
- 在列表之间移动元素
users=['Bob','Alice','Joey']
new_users=[]
while users:
user=users.pop()
new_users.append(user)
print(users)
print(new_users)- 删除为特定值的所有列表元素
pets=['dogs','cat','dog','rabbit','dog','wolf']
while 'dog' in pets:
pets.remove('dog')
print(pets)- 使用用户输入来填充字典
responses={}
flag=True
while flag!='no':
name=input("What's your name:")
response=input("Do you like Basketball(yes/no):")
responses[name]=response
flag=input("anyone else?(yes/no):")
print(responses)七、函数
（一）创建函数
函数是带名字的代码块，用于完成具体的工作，使用关键词def来定义。
- 定义函数
def greet_user():
print("Hello!")
greet_user() #调用定义的函数- 向函数传递信息
def language(name,language): #形参
print(f"{name} is good at {language}")
language('Bob','Python') #实参
language('Alice','C')- 形参指定默认值后，可在函数调用中省去相应的实参
def pet(name,type='dog'): #'type'为默认值
print(f"Its name is {name}\nIts type is {type}")
pet('Dabai')- 返回函数值
def format_name(first_name,last_name):
name=f"{first_name.title()} {last_name.title()}"
return name
name=format_name('li','wasai')
print(name)- 传递任意数量的实参
def make_pizza(size,*toppings):
print(f"\nMaking a {size}-inch pizza with the following toppings:")
for topping in toppings:
print(f"- {topping}")
make_pizza(16,'mushrooms','green peppers','extra cheese')- 使用任意数量的关键字实参
def build_profile(first,last,**user_info):
user_info['first_name']=first
user_info['last_name']=last
return user_info
user_profile=build_profile('Li','Wasai',
location='Jining',field='computer')
print(user_profile)（二）导入函数
- 导入特定的函数
from numpy import array,arange- 使用as指定别名
import numpy as np
np.array([1,2,3,4,5])- 导入模块中所有函数
from numpy as *
array([1,2,3,4,5])八、类
面向对象编程
根据类来创建对象称为实例化
（一）创建和使用类
- 创建Dog类和实例
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
self.steps = 0 给属性制定默认值，无需再用形参来定义
def sit(self):
print(f"{self.name} is now sitting")
def roll_over(self):
print(f"{self.name} rolled over")
def run(self):
print(f"{self.name} have run {self.steps} steps")
def update_run(self,steps): #通过方法修改属性的值
self.steps=steps
#使用类和实例
my_dog = Dog('Dabai', 6)
print(f"its name is {my_dog.name}\nits age is {my_dog.age}")
my_dog.sit() #调用方法
my_dog.roll_over()
my_dog.run()
my_dog.update_run(10000)
my_dog.run()- 方法__init__()
方法__init__()是类必不可少的，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定。
（二）继承
- 父类
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=f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
print(f"This car has {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 adometer!")
def increment_odometer(self,miles):
self.odometer_reading+=miles- 子类
class Car:
--snip--
class ElectricCar(Car): #定义子类时，必须在圆括号内指定父类的办法
def __init__(self,make,model,year):
super().__init__(make,model,year) #super()让你能够调用父类的办法
self.battery_size=75 #让子类定义属性
def describe_battery(self): #让子类定义方法
print(f"This car has a {self.battery_size}-kwh battery")
def fill_gas_tank(self): #重写父类的方法
print("This car doesn't need a gas tank!")
my_tesla=ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()3.将实例用作属性
class Car:
--snip--
class Battery: #定义一个新类，表示电动汽车电瓶的属性和方法
def __init__(self,battery_size=75):
self.battery_size
def describe_battery(self):
print(f"This car has a {self.battery_size}-kwh battery")
class ElectricCar(Car): #定义子类时，必须在圆括号内指定父类的办法
def __init__(self,make,model,year):
super().__init__(make,model,year) #super()让你能够调用父类的办法
self.battery=Battery() #创建Battery实例赋给属性self.battery
def fill_gas_tank(self): #重写父类的方法
print("This car doesn't need a gas tank!")
my_tesla=ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
