Python基础知识

最新推荐文章于 2024-11-04 21:51:40 发布

孙子杨

最新推荐文章于 2024-11-04 21:51:40 发布

阅读量396

点赞数 2

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_35594345/article/details/126476813

版权

Python编程基础练习

本人学习过C语言，正在学习Python机器学习算法，所以从第三章开始学习，完整内容请按照原书进行：Python编程从入门到实践（从第三章起）

第三章：列表简介

bicycle=['trek','cannondale','redline','specialized']
print('bicycle=',bicycle)              #

bicycle= ['trek', 'cannondale', 'redline', 'specialized']

bicycle=['trek','cannondale','redline','specialized']
print('bicycle=',bicycle[0].title())

bicycle= Trek

bicycle=['trek','cannondale','redline','specialized']
print('bicycle=',bicycle[-1].title()) #负数是从最右侧开始的，-1表示从最右侧开往左数一列

bicycle= Specialized

bicycle=['trek','cannondale','redline','specialized']
bicycle[1]='adc'
print('bicycle=',bicycle[1].title())

bicycle= Adc

bicycle=['trek','cannondale','redline','specialized']
bicycle.append('adc')     #append只在最后一行插入
bicycle.insert(0,'apc')   #insert使用参数在任意位置插入
print('bicycle=',bicycle)

bicycle= ['apc', 'trek', 'cannondale', 'redline', 'specialized', 'adc']

bicycle=['trek','cannondale','redline','specialized']
a=bicycle.append('adc')     #append只在最后一行插入
b=bicycle.insert(0,'apc')   #insert使用参数在任意位置插入
print('bicycle=',bicycle)
print('a=',a)                     #append、insert只是操作，不会传出值
print('b=',b)

bicycle= ['apc', 'trek', 'cannondale', 'redline', 'specialized', 'adc']
a= None
b= None

bicycle=['trek','cannondale','redline','specialized']
del bicycle[0]
print('bicycle=',bicycle)

bicycle= ['cannondale', 'redline', 'specialized']

bicycle=['trek','cannondale','redline','specialized']
print('bicycle=',bicycle)
a=bicycle.pop()
print('bicycle=',bicycle)
print('a=',a)

b=bicycle.pop(0)   #pop括号里面什么都没有，删除最后一位，有参数，删除参数位，pop可以传出来值
print('bicycle=',bicycle)
print('b=',b)

bicycle= ['trek', 'cannondale', 'redline', 'specialized']
bicycle= ['trek', 'cannondale', 'redline']
a= specialized
bicycle= ['cannondale', 'redline']
b= trek

bicycle=['trek','cannondale','redline','specialized']
a='trek'
bicycle.remove(a)
print('bicycle=',bicycle)

bicycle= ['cannondale', 'redline', 'specialized']

bicycle=['trek','cannondale','redline','specialized']
bicycle.sort()
print('bicycle=',bicycle)

bicycle= ['cannondale', 'redline', 'specialized', 'trek']

bicycle=['trek','cannondale','redline','specialized']
bicycle.sort(reverse=True)        #参数True表示字母倒叙排列，False表示字母正序排列
print('bicycle=',bicycle)

bicycle= ['trek', 'specialized', 'redline', 'cannondale']

bicycle=['trek','cannondale','redline','specialized']
a=sorted(bicycle,reverse=False)        #参数True表示字母倒叙排列，False表示字母正序排列；sorted临时排序，没有改变数据原来的顺序
print('a=',a)
print('bicycle=',bicycle)

a= ['cannondale', 'redline', 'specialized', 'trek']
bicycle= ['trek', 'cannondale', 'redline', 'specialized']

bicycle=['trek','cannondale','redline','specialized']
bicycle.reverse()                      #倒序打印
print('bicycle=',bicycle)

bicycle= ['specialized', 'redline', 'cannondale', 'trek']

bicycle=['trek','cannondale','redline','specialized']
a=len(bicycle)                       #计算数据的长度
print('a=',a)

a= 4

第四章：操作列表

magicians=['alice','david','carolina']
for magicians in magicians:
    print(magicians)

alice
david
carolina

magicians=['alice','david','carolina']
for z in magicians:                    #循环三次，z的值因为for遍历了整个列表
    print(magicians)

['alice', 'david', 'carolina']
['alice', 'david', 'carolina']
['alice', 'david', 'carolina']

magicians=['alice','david','carolina']
for z in magicians: #for是遍历整个列表，对于列表，只要使用for都是全部遍历
    print(z)

alice
david
carolina

magicians=['alice','david','carolina']
for magicians in magicians:
    print(magicians)
print('hello')               #看准缩放，在for循环里，按照循环走，不在循环里（冒号包括的内容之外），不走循环

alice
david
carolina
hello

书中有这样一句段话：Python根据缩放来判断代码行与前一个代码行的关系。Python通过缩放让代码更易懂，简单地说，Python要求使用者使用缩进让代码更加整洁而结构清晰。

for value in range(1,5):  #range()函数，括号里面的第一个参数是起始（包含），第二个参数是终止位（不包含），中间都是整数
    print(value)
for a in range(2,6):  #range()函数，括号里面的第一个参数是起始（包含），第二个参数是终止（ 不包含），中间都是整数
    print(a)

a=list(range(2,11,2))  #第三个参数是步长

a=[]
for b in range(1,11):
    c=b**2
    a.append(c)
print(a)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

a=[1,2,3,4,5,6,7,8,9,0]
b=min(a)
c=max(a)
d=sum(a)
print(a,b,c,d)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0] 0 9 45

a=[b**2 for b in range(1,11)]     #列表解析
print(a)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

player=['charles','martina','michael','florence','eli']
print(player[0:3])          #[]左边参数不包括，右侧包括
print(player[1:3])          #[]左边参数不包括，右侧包括
print(player[:3])           #左边所有的元素直到参数2（包括）
print(player[:])            #遍历所有的元素
print(player[-3:])          #最右侧往左数数
print(player[-3:-2])        #倒数第三个到倒数第二个，那就是倒数第二个
print(player[-2:-3])        #倒数第二个到倒数第三个，为空，输出[]
for a in player[:3]:        #遍历切片
    print(a)

['charles', 'martina', 'michael']
['martina', 'michael']
['charles', 'martina', 'michael']
['charles', 'martina', 'michael', 'florence', 'eli']
['michael', 'florence', 'eli']
['michael']
[]
charles
martina
michael

player=['charles','martina','michael','florence','eli']
a=player
player.append('kid')        #a=player这种操作是将a与player绑定在一起，两个变量进行了关联
b=player[:]                 #b=player[:]是复制操作，两个变量并没有绑定在一起，所以可以分别操作
b.append('apc')
print(player)
print(a)
print(b)

['charles', 'martina', 'michael', 'florence', 'eli', 'kid']
['charles', 'martina', 'michael', 'florence', 'eli', 'kid']
['charles', 'martina', 'michael', 'florence', 'eli', 'kid', 'apc']

书中有一段话：列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值成为不可变的，而不可变的列表被称为元组。
元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

a=(1,2)
for a in a:
    print(a)

1
2

a=(1,2)
a=(2,4)         #可对变量重新赋元组，从而更新元组，但是不能改变某个元组内部的值
for a in a:
    print(a)

2
4

书中有一段话，严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号，创建只包含一个元素的元组通常没有意义，但自动生成的元组有可能只有一个元素。

a=(1,)
b=(2)
print(a)            #直接输出a,不是以遍历的形式输出
for a in a:
    print(a)
# for b in b:
#     print(b)      # b这种定义，不是元组，不能使用遍历这种方法输出
print(a)            #直接输出a,不是以遍历的形式输出
print(b)            #这种方法输出形式是可以的

(1,)
1
1
2

第六章：字典

alien={'color':'green'} #字典使用的是大括号{}
a=alien['color']
print(a)
print(alien)

green
{'color': 'green'}

alien={'color':'green'} #字典定义使用的是大括号{}，但是对其中某一个组成元素操作使用的是中括号[]
alien['x']=0
alien['y']=20
a=alien['color']
print(a)
print(alien)

green
{'color': 'green', 'x': 0, 'y': 20}

alien={'color':'green'} #字典定义使用的是大括号{}，但是对其中某一个组成元素操作使用的是中括号[]
alien['x']=0
alien['y']=20
a=alien['color']
print(a)
print(alien)
alien['color']='yellow'   #改变元素的值
print(alien)

green
{'color': 'green', 'x': 0, 'y': 20}
{'color': 'yellow', 'x': 0, 'y': 20}

alien={'x':0,'y':25,'speed':'medium'}
if alien['speed']=='fast':
    a=1
elif alien['speed']=='medium':
    a=2
else: 
    alien['speed']=='slow'
a=3
alien['x']=alien['x']+a
print(alien['x'])
print(alien['speed'])

3
medium

alien={'x':0,'y':25,'speed':'medium'}
print(alien)
del alien['x']
print(alien)

{'x': 0, 'y': 25, 'speed': 'medium'}
{'y': 25, 'speed': 'medium'}

alien={
    'x':0,
    'y':25,
    'speed':'medium'
}
print(alien)
del alien['x']
print(alien)

{'x': 0, 'y': 25, 'speed': 'medium'}
{'y': 25, 'speed': 'medium'}

alien={
    'x':1,
    'y':25,
    'speed':'medium'
}
a=alien.get('x',0)
b=alien.get('z',0) #get()函数，第一个参数是去寻找的对象，如果找到了，将其值返回，如果没找到，返回第二个参数
print(a)
print(b)

1
0

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi'
}
for key,value in user_0.items():  #两个参数，第一个对应健名，第二个对应键值；items()返回一个键值对列表
    print(key)
    print(value)

username
efermi
first
enrico
last
fermi

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi'
}
for key in user_0.keys():  #keys()返回字典的列表，列表里面包含字典中的所有键
    print(key)

username
first
last

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi'
}
for key in sorted(user_0.keys()):  #keys()返回字典的列表，列表里面包含字典中的所有键；sorted（）对字典按照键名进行排序，返回一个排列好顺序的列表；
    print(key)

first
last
username

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi'
}
for key in user_0.values():  #values()返回一个列表，列表中包含的是键值
    print(key)

efermi
enrico
fermi

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi',
    'middle':'fermi'
}
for a in user_0.values():  #values()返回一个列表，列表中包含的是键值
    print('a=',a)
for b in set(user_0.values()):  #set()返回一个列表，列表中包含的是键值（筛选掉重复的）
    print('b=',b)

a= efermi
a= enrico
a= fermi
a= fermi
b= efermi
b= fermi
b= enrico

字典与列表的三中嵌套形式：字典嵌套在列表里（字典列表）、列表嵌套在字典里（在字典里存储列表）、字典嵌套在字典里（在字典里储存字典）；

#字典嵌套在列表里（字典列表）
a={'name':'dog',
   'color':'yellow',
   'money':100
  }
b={'name':'cat',
   'color':'white',
   'money':1000
  }
c={'name':'clock',
   'color':'blue',
   'money':30
  }
d={'name':'bag',
   'color':'black',
   'money':300
  } 
d=[a,b,c,d]                            
for z in d:
    print(z)

{'name': 'dog', 'color': 'yellow', 'money': 100}
{'name': 'cat', 'color': 'white', 'money': 1000}
{'name': 'clock', 'color': 'blue', 'money': 30}
{'name': 'bag', 'color': 'black', 'money': 300}

pizza={
    'crust':'thick',
    'toppongs':['mushroom','extra cheese'],
}
print(pizza['crust'])

thick

#字典嵌套在列表里（字典列表）
things={
    'a':{'name':'dog',
         'color':'yellow',
         'money':100
        },
    'b':{
        'name':'cat',
        'color':'white',
        'money':1000
    },
    'c':{
        'name':'clock',
        'color':'blue',
        'money':30
    },
    'd':{
        'name':'bag',
        'color':'black',
        'money':300
    }
}                            
for z ,l  in things.items() :
    print(z,l)
for x in things.keys():
    print(x)
for y in things.values():
    print(y)

a {'name': 'dog', 'color': 'yellow', 'money': 100}
b {'name': 'cat', 'color': 'white', 'money': 1000}
c {'name': 'clock', 'color': 'blue', 'money': 30}
d {'name': 'bag', 'color': 'black', 'money': 300}
a
b
c
d
{'name': 'dog', 'color': 'yellow', 'money': 100}
{'name': 'cat', 'color': 'white', 'money': 1000}
{'name': 'clock', 'color': 'blue', 'money': 30}
{'name': 'bag', 'color': 'black', 'money': 300}

第七章：用户输入和while循环

massage=input('please input a number:')
print('massage=',massage)

please input a number:12
massage= 12

a='你好啊，小朋友'
a+='，吃饭了吗？'
name=input(a)
print(name)

你好啊，小朋友，吃饭了吗？yes
yes

a='18'
b=int(a)         #int()，将变量类型强制转换为int型
print(b+1)

3%2 #求模运算符%

a=['1','2','1','4','5']
while '1' in a:
    print('hello word')
    break

hello word

a=['1','2','1','4','5']
while '1' in a:
    a.remove('1')
    print('hello word')

hello word
hello word

a=['1','2','1','4','5']
while '1' in a:
    a.remove('1')
    print('hello word')
    break

hello word

a=['1','2','1','4','5']
while '1' in a:
    a.remove('1')
    print('hello word')
    continue

hello word
hello word

responses={}
polling_active=True
while polling_active:
    name=input('what is your name?')
    reponse=input('which mountain would you like to climb someday?')
    responses[name]=reponse
    repeat=input('would you like to let another person repond?(yes/no)')
    if repeat=='no':
        polling_active=False
print('\n---poll results---')
for name,response in responses.items():
    print(f'{name} would like to climb {response}.')

what is your name?sun
which mountain would you like to climb someday?west
would you like to let another person repond?(yes/no)yes
what is your name?yu
which mountain would you like to climb someday?hill
would you like to let another person repond?(yes/no)no

---poll results---
sun would like to climb west.
yu would like to climb hill.

第八章：函数

def describe_pet(pet_name,animal_type='dog'):
    print(f'\nI have a{animal_type}.')
    print(f"My {animal_type}'s name is {pet_name.title()}.")
    
describe_pet('willie')
describe_pet(pet_name='willie')

describe_pet('harry','hamster')
describe_pet(pet_name='harry',animal_type='hamster')
describe_pet(animal_type='hamster',pet_name='harry')

I have adog.
My dog's name is Willie.

I have adog.
My dog's name is Willie.

I have ahamster.
My hamster's name is Harry.

I have ahamster.
My hamster's name is Harry.

I have ahamster.
My hamster's name is Harry.

def make_pizza(*toppings):     #*表示建立一个元组toppings，将所有的变量都收入进这个元组里，来着不拒
#打印顾客点的所有配料
    print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

def make_pizza(size,*toppings):     #默认函数的第一个参数储存在size中，*表示建立一个元组toppings，将第一个参数后面的所有的参数都收入进这个元组里，来着不拒
#打印顾客点的所有配料
    print(size,toppings)
make_pizza(16,'pepperoni')
make_pizza(20,'mushrooms','green peppers','extra cheese')

16 ('pepperoni',)
20 ('mushrooms', 'green peppers', 'extra cheese')

def build_profile(first,last,**user_info):         #**user_info中的两个星号让python创建一个名为user_info的空字典，并将收到的所有名称值对都放在这个字典里
    user_info['first_name']=first 
    user_info['last_name']=last
    return user_info

user_profile=build_profile('albert','einstein',
                          locatinon='princeton',
                           field='physics'
                          )
print(user_profile)

{'locatinon': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

多种导入模块（函数库）的方法

#引用函数库里的函数的时候形如(注意中间用点进行引用):module_name.function_name  
import module_name                                              
#导入模块（函数库）中的特定函数，使用函数的时候不需再采用点来引用
from module_name import function_name            
#导入模块（函数库）中的所有函数，使用*代替所有函数，使用函数的时候不需再采用点来引用
from module_name import *    
#导入模块（函数库）中的特定函数，并且使用另一个名字代替函数名，使用函数的时候不需再采用点来引用
from module_name import function_name as mp               
#导入模块（函数库），并且函数库的名字用另一个名字来代替，引用函数库里的函数的时候形如(注意中间用点进行引用,mp.function_name 
import module_name as mp

第九章：类

class Dog:                             #根据约定，在Python中，首字母大写的名称指的是类，类中的函数被称为方法
    
    def __init__(self,name,age):       
    #__init__是（）是一个特殊的方法，开头和结尾各有两个下划线（一种约定，务必遵守）
    #每当根据类创建实例的时候，Python会自动运行它，形参self必不可少，且必须位于其他形参前面，在调用的时候，Python自动调用
    #所有形参self不需要在调用的时候赋值给self，self是指向实例本身的引用，让实例能够访问类中的属性和方法
    #创建实例的时候，Python将调用类的方法__init__()，只需要通过实参向类传递后面的参数，self会自动传递，因此不需要传递它
        self.name=name
        self.age=age
    #以self为前缀的变量（可通过实例访问的变量叫做属性）可供类中的其他方法（函数）使用，可以通过类的任何实例来访问
        
    def sit(self):
        print(f'{self.name} is now sitting.')
    
    def roll_over(self):
        print(f'{self.name} rolled over!')

my_dog=Dog('Willie',6)
#让Pthon创建一条名为'Willie'、年龄为6的小狗。遇到这行代码时，Python使用实参'Willie'和6调用Dog类的方法__init__（）。
#__init__（）创建一个表示特定小狗的实例，并通过提供的值来设置属性name和age。接下来Python返回一个表示特定小狗的实例
#通常，首字母大写的名称表示类，小写的名称指的是根据类创建的实例

print(f"My dog's name is {my_dog.name}.")   #访问实例的属性，可用句点表示法
print(f"My dog is {my_dog.age} year old.")

my_dog.sit()           
#根据类创建实例后，就能使用句点表示法来调用类中定义的任何方法了
#要调用方法，可指定实例的名称和要调用的方法，并用句点分割
#遇到代码my_dog.sit()时，Python在类Dog中查找方法sit()并运行其代码
my_dog.roll_over()

My dog's name is Willie.
My dog is 6 year old.
Willie is now sitting.
Willie rolled over!

class Dog:                          
    
    def __init__(self,name,age):       
        self.name=name
        self.age=age
        
    def sit(self):
        print(f'{self.name} is now sitting.')
    
    def roll_over(self):
        print(f'{self.name} rolled over!')

my_dog=Dog('Willie',6)
my_dog.age=8           #直接修改实例的属性值


print(f"My dog's name is {my_dog.name}.")   
print(f"My dog is {my_dog.age} year old.")

my_dog.sit()           
my_dog.roll_over()

My dog's name is Willie.
My dog is 8 year old.
Willie is now sitting.
Willie rolled over!

class Dog:                          
    
    def __init__(self,name,age):       
        self.name=name
        self.age=age
    
    def update_age(self,new_age):
        self.age=new_age
        
    def sit(self):
        print(f'{self.name} is now sitting.')
    
    def roll_over(self):
        print(f'{self.name} rolled over!')

my_dog=Dog('Willie',6)
my_dog.update_age(8)           #通过方法修改实例的属性值


print(f"My dog's name is {my_dog.name}.")   
print(f"My dog is {my_dog.age} year old.")

my_dog.sit()           
my_dog.roll_over()

My dog's name is Willie.
My dog is 8 year old.
Willie is now sitting.
Willie rolled over!

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_odemeter(self,mileage):
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self,miles):
        self.odometer_reading+=miles


class ElectricCar(Car):          #定义子类时，必须在圆括号里指定父类的名称
    
    def __init__(self,make,model,year):    #子类的__init__方法，接受创建Car实例所需的信息    
        #super()是一个特殊的函数，能够调用父类的方法__init__，让子类包含这种方法中定义的所有属性
        #父类也成为超类(superclass) ，名称super由此而来
        super().__init__(make,model,year) 
        
my_tesla=ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())

2019 Tesla Model S

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_odemeter(self,mileage):
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self,miles):
        self.odometer_reading+=miles
           
    def fill_gas_tan(self):
        print("This car needs 50L gas to fill a tank!")


class ElectricCar(Car):         
    
    def __init__(self,make,model,year):   
        super().__init__(make,model,year) 
        self.battery_size=75
    
    def descibe_battery(self):
        print(f"This car has a {self.battery_size}-kwh battary.")
    
    def fill_gas_tan(self):     #将父类中的方法直接进行重写
        print("This car doesn't need a gas tank!")
    
        
my_tesla=ElectricCar('tesla','model s',2019)
my_car=Car('BYD','han',2020)    #在子类中对父类的方法改写对父类没有影响 

print(my_tesla.get_descriptive_name())
my_tesla.descibe_battery()
my_tesla.fill_gas_tan()
my_car.fill_gas_tan()

2019 Tesla Model S
This car has a 75-kwh battary.
This car doesn't need a gas tank!
This car needs 50L gas to fill a tank!

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_odemeter(self,mileage):
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self,miles):
        self.odometer_reading+=miles
           
    def fill_gas_tan(self):
        print("This car needs 50L gas to fill a tank!")

class Battery:
    
    def __init__(self,battery_size=75):
        self.battery_size=battery_size
        
    def describe_battery(self):
        print(f"This car has a {self.battery_size}-kwh battery.")
    
    def get_range(self):
        if self.battery_size==75:
            range=260
        elif self.battery_size==100:
            range=315
        print(f"This car can go about {range} miles on a full charge.")




class ElectricCar(Car):         
    
    def __init__(self,make,model,year):   
        super().__init__(make,model,year) 
        self.battery=Battery() #将属性设置为一个类（上面Battery定义的类）,将属性拆分为多个属性（多个属性以一个类的形式存在）
    
    
        
my_tesla=ElectricCar('tesla','model s',2019)


print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

2019 Tesla Model S
This car has a 75-kwh battery.
This car can go about 260 miles on a full charge.

类模块的导入和函数的导入方法和规则类似

第十章：文件和异常

with open('pi_digits.txt') as file_object:
    #文件只有先打开，才能访问它。open()接受一个参数：要打开的文件的名称
    #Python在当前执行的文件所在位置中查找指定的文件；Open()返回一个表示文件的对象，并且将对象赋值（本例中赋值为file_object)
    #关键字with在不需要访问文件时自动将其关闭
    #open()对应着close()，但是程序存在bug，close()未执行，文件将不会关闭，使用with，Python会在合适的时候将文件自动关闭
    contents=file_object.read()   #read()读取文件的全部内容
print(contents)  
#输出值最后面有一个空行，因为read()到达文件末尾时返回一个空字符串，显示出来就是空行，解决办法是在函数调用print时使用rstrip()
print(1+1)

3.1415926535
  8979323846
  2643383279
2

with open('pi_digits.txt') as file_object:
    contents=file_object.read()   
print(contents.rstrip())
print(1+1)

3.1415926535
  8979323846
  2643383279
2

通过使用绝对路径，可以读取系统中任何地方的文件

file_path='/home/ehmatthes/other_files/text_files/filename.txt'
with open(file_path) as file_object:

相对路径的表示方法：

with open ('text_files/filename.txt') as file_object:

如果在文件路径中直接使用反斜杠，将引发错误，因为反斜杠用于对字符串中的字符进行转义
例如，对于路径

C:\path\to\file.txt

其中的\t将被解读为制表符。如果一定要加反斜杠，可对路径中的每个反斜杠都进行转义，如

C:\\path\\to\\file.txt

filename='pi_digits.txt'

with open (filename) as file_object:
    for line in file_object:   #为了查看内容，通过对文件对象执行循环来遍历文件的每一行
        print(line)

3.1415926535

  8979323846

  2643383279

filename='pi_digits.txt'

with open (filename) as file_object:
    for line in file_object:  
        print(line.rstrip())   #为了消除多余的空白行，可在函数调用print()中使用rstrip()

3.1415926535
  8979323846
  2643383279

filename='pi_digits.txt'

with open (filename) as file_object: #with 关键字使得文件内容的使用都在冒号范围内
    lines=file_object.readlines()    
    #为了在with范围外使用文件内容，可以将文件的内容的各行都存储在一个列表里，这样可以在需要的时候处理文件里的内容
    #readlines()函数从文件中读取每一行
    
for line in lines:  
    print(line.rstrip())   #为了消除多余的空白行，可在函数调用print()中使用rstrip()

3.1415926535
  8979323846
  2643383279

filename='pi_digits.txt'

with open (filename) as file_object: 
    lines=file_object.readlines()    

pi_string=''   #创建一个变量pi_string，指向圆周率的值，接下来使用循环，将数据的各行加入pi_string，并删除末尾的换行符
    
for line in lines:  
    pi_string+=line.rstrip()
    
print(pi_string)
print(len(pi_string))

3.1415926535  8979323846  2643383279
36

filename='pi_digits.txt'

with open (filename) as file_object: 
    lines=file_object.readlines()    

pi_string=''
    
for line in lines:  
    pi_string+=line.strip()  #变量pi_string指向的字符串包含原来位于每行左边的空格，为删除这些空格，可使用strip()，而非rstrip()
    
print(pi_string)
print(len(pi_string))

3.141592653589793238462643383279
32

filename='pi_million_digits.txt'

with open(filename) as file_object:
    lines=file_object.readlines()

pi_string=''

for line in lines:
    pi_string+=line.strip()

print(f"{pi_string[:52]}...") #输出字符串小数点后50位（整数位+小数位=51位）
print(len(pi_string))

3.14159265358979323846264338327950288419716939937510...
1000002

filename='programing.txt'

with open(filename,'w')as file_object:
    #本例中，调用open()时提供两个实参，第一个实参也时要打开的文件的名称，第二个实参（'w')告诉Python，要以写入模式打开这个文件
    #打开文件时，可指定读取模式('r')、写入模式('w')、附加模式('a')或读写模式('r+')，如果省略了模式参数，Python默认以只读模式打开文件
    #如果写入的文件不存在，函数open()将自动创建它
    #然而以只读模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空改文件的内容
    file_object.write("I love programing.\n")
    file_object.write("I love creating new games.\n")

filename='programing.txt'

with open(filename)as file_object:
    for line in file_object.readlines():
        print(line.rstrip())

I love programing.
I love creating new games.

本例中，调用open()时提供两个实参，第一个实参也时要打开的文件的名称，第二个实参（‘w’)告诉Python，要以写入模式打开这个文件；
打开文件时，可指定读取模式(‘r’)、写入模式(‘w’)、附加模式(‘a’)或读写模式(‘r+’)，如果省略了模式参数，Python默认以只读模式打开文件；
如果写入的文件不存在，函数open()将自动创建它，然而以只读模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空改文件的内容；
如果要给文件添加内容，而不是覆盖原有的内容，可以以附加模式打开。以附加模式打开文件时，Python不会再返回文件对象前清空文件的内容，而是将写入文件的行添加到文件末尾，如果指定的文件不存在，Python将为你创建一个空文件。

filename='programing.txt'

with open(filename,'a') as file_object:
        file_object.write("I also love finding meaning in large datasets.\n")
        file_object.write("I love creating apps that can run in a browser.\n")

filename='programing.txt'

with open(filename)as file_object:
    for line in file_object.readlines():
        print(line.rstrip())

I love programing.
I love creating new games.
I also love finding meaning in large datasets.
I love creating apps that can run in a browser.

孙子杨

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫