Python部分基本操作、函数与方法集合

叁歲伎倆 2023-10-06 07:21 68阅读 0赞

Python部分基本操作、函数与方法集合

目录

  • Python部分基本操作、函数与方法集合
    • 1.变量、简单数据类型、列表、if语句：
      • 操作：
      • 函数：
      • 方法：
    • 2.字典、用户输入和while循环
      • 操作：
      • 函数：
      • 方法：
    • 3.函数
      • 操作：
    • 4.类
      • 操作：
    • 5.文件：
      • 从文件中读取数据：
      • 写入文件：
      • 存储数据：

1.变量、简单数据类型、列表、if语句：

操作：

  1. 3**2    用两个乘号表示乘方运算
  3. #        用#标识注释
  5. bicycles=[ 'trek','cannondale','redline','specialized' ]   
  6. #用[]表示列表，用逗号分隔其中的元素
  8. print( bicycles[-1] )    
  9. #将索引指定为-1，可返回最后一个列表元素，-2为倒数第二个，依次类推
  11. del  motorcycles[0]      
  12. #删除列表中的元素，0为其索引
  14. #for循环：
  15. magicians=['alice','david','carolina']
  16. #从列表magicians中取出一个名字，并将其存储在变量magician中，
  17. #在该行后每个缩进的代码行都是循环的一部分
  18. for magician in magicians:    
  19.     print( magician )
  21. squares=[ value**2 for value in range(1,11) ]    
  22. #列表解析，将for循环和创建新元素合并
  24. print(players[0:3])    
  25. #列表的切片，其中包含列表的前三个元素，打印的输出也是一个列表，
  26. #要创建切片，可指定要使用的第一个元素的索引和最后一个元素的索引加1
  28. print(players[:4])      
  29. #若没有指定第一个索引，将自动从列表表头开始
  31. print(players[2:])      
  32. #省略终止索引，切片将终止于列表末尾
  34. print(players[-3:])     
  35. #输出列表的最后三个元素（负数索引返回离列表末尾相应距离的元素）
  37. for player in players[:3]:     #通过切片遍历列表的部分元素
  38.     print(player.title() )     
  40. my_foods=['pizza','falafel','carrot cake'] 
  41. friend_foods=my_foods[:]      
  42. #复制列表（同时省略起始和终止索引，创建一个包含整个列表的切片）
  43. your_foods=my_foods           
  44. #将新变量关联到包含在my_foods中的列表，这两个变量都指向同一个列表
  46. dimensions=(200,50)         #用圆括号定义元组，元组为不可变的列表
  47. print(dimensions[0])        #使用索引访问元组的元素
  48. dimensions=(400,100)        #给元组变量赋值（可修改元组变量）
  50. cars=['audi','bmw','subaru','toyota']
  51. for car in cars:
  52.     if car=='bmw':                #if语句的使用
  53.         print( car.upper() )
  54.     else
  55.         print( car.title() )
  57. age_0=22
  58. age_1=18
  59. age_0>=21 and age_1>=21      #用and检查多个条件（且用and表示）
  60. age_0>=21 or age_1>=21       #或用or表示
  62. requested_toppings=['mushrooms','onions','pineapple']
  63. 'mushroom' in requested_toppings     
  64. #用in检查特定值是否包含在列表中
  65. 'apple' not in requested_toppings    
  66. #用not in检查特定值是否不包含在列表中
  68. if condition_test:          #if语句的使用
  69.     do something             #若条件满足，将执行if后面所有缩进的代码行
  71. if condition_test:          #if else的使用
  72.     do something
  73. else:
  74.     do otherthing
  76. if age<4:                                    #if-elif-else结构
  77.     print("Your admission cost is $0.")
  78. elif age<18:
  79.     print("Your admission cost is $5.")
  80. else
  81.     print("Your admission cost is $10.")
  83. requested_toppings=[]
  84. if requested_toppings:         #判断列表是否为空
  85.     do something

函数：

  1. str()           #将非字符串值表示为字符串
  3. sorted( cars )   
  4. #按特定顺序显示列表元素，同时不影响元素在列表中的原始排列顺序
  6. len( cars )     #返回列表的长度
  8. range(x,y)     #从x开始数，在达到y时停止
  9. for value in range(1,5):
  10.     print( value )        #打印1~4
  12. list()         #可将range()的结果直接转换成列表
  13. numbers=list( range(1,6) )
  15. range( x,y,z )   #指定步长为z的range
  16. even_numbers=list( range(2,11,2) )     
  17. #range从2开始，不断加2，直至超过或达到11
  19. min(digits)      #列表的最小值
  20. max(digits)      #列表的最大值
  21. sum(digits)      #列表的总和

方法：

  1. name.title()   #以首字母大写方式显示每个单词
  3. name.rstrip()  #删除字符串结尾多余的空白
  5. name.lstrip()  #删除字符串开头的空白
  7. name.strip()   #删除字符串两端的空白
  9. title.split()    
  10. #以空格为分隔符将字符串分拆成多个部分，并将这些部分存储在一个列表中
  12. motorcycles.append('ducati')    #在列表末尾添加元素
  14. motorcycles.insert(0,'ducati')  #在列表中添加新元素，0为新元素的索引
  16. popped_motorcycle=motorcycles.pop()   
  17. #将元素从列表中删除，并返回它的值
  19. first_owned=motorcycles.pop(0)    #弹出列表中任何位置的元素，0为其索引
  21. motorcycles.remove( 'ducati' )    #删除列表中第一个值为ducati的元素
  23. cars.sort()    #排序列表元素
  25. cars.sort( reverse=True )         #逆序排列列表元素
  27. cars.reverse   #反转列表元素的排列顺序

2.字典、用户输入和while循环

字典：
字典是一系列 键——值对。每个键都与一个值相关联，可使用键来访问与其关联的值。与键关联的值可以为数字、字符串、列表、字典。实际上，可将任何python对象用作字典中的值。
字典用放在{}中的一系列键——值对表示。键——值对是两个相关联的值。指定键时，python将返回与之关联的值。键和值之间用冒号：分隔，键——值对之间用逗号分隔

操作：

  1. alien_0={
  2.     'color':'green','points':5}       
  3. #字典alien_0存储了外星人的颜色和点数
  5. print( alien_0['color'] )       
  6. #获取与键相关联的值，依次指定字典名和放在方括号[]内的键
  7. print( alien_0['points'] )
  9. alien_0['x_position']=0            
  10. #添加键——值对，依次指定字典名，用方括号[]括起来的键和相关联的值
  11. alien_0['y_position']=25
  13. alien_0['color']='yellow'        #修改字典中的值
  15. alien_0={
  16.     }             #创建空字典
  18. del alien_0['points']         #删除键——值对（需指定字典名和要删除的键）
  20. favorite_languages={
  22. #由类似对象组成的字典（使用字典存储众多对象的同一信息）
  23.     'jen':'python',
  24.     'sarah':'c',
  25.     'edward':'ruby',
  26.     'phil':'python',
  27.     }
  29. user_0={
  31.     'username':'efermi',
  32.     'first':'enrico',
  33.     'last':'fermi',
  34.     }
  36. for key,value in user_0.items():    
  37. #遍历所有的键——值对，声明两个变量用于存储键——值对中的键和值，
  38. #遍历时键——值对的返回顺序与存储顺序不同
  39.     print("\nKey:"+key)
  40.     print("Value:"+value)
  42. for name in favorite_languages.keys():    
  43. #遍历字典中的所有键
  44. #（等价于 for name in favorite_languages:  因为遍历字典时默认遍历键）
  45.     print(name.title())
  47. for name in sorted( favorite_languages.keys() ):    
  48. #按顺序遍历字典中的所有键
  49.     do something
  51. for language in favorite_languages.values():    #遍历字典中的所有值
  52.     do something
  54. for language in set( favorite_languages.values() )    
  55. #通过对包含重复元素的列表调用set()，
  56. #找出列表中独一无二的元素，并使用这些元素创建集合
  57.     do something
  59. alien_0={
  60.     'color':'green','point':5}
  61. alien_1={
  62.     'color':'yellow','point':10}
  63. alien_2={
  64.     'color':'red','point':15}
  65. aliens=[alien_0,alien_1,alien_2]    
  66. #字典列表，此为包含3个三个字典的列表
  67. for alien in aliens:
  68.     print(alien)
  70. pizza={
  72. #在字典中存储列表，
  73. #每当需要在字典中将一个键关联到多个值时，都可在字典中嵌套一个列表
  74.     'crust':'thick',
  75.     'toppings':['mushrooms','extra cheese'],
  76.     }
  78. users={
  79.                                 #在字典中存储字典
  80.     'aeinstein':{
  82.         'first':'albert',
  83.         'last':'einstein',
  84.         'location':'princeton',
  85.         },
  86.     'mcurie':{
  88.         'first':'marie',
  89.         'last':'curie',
  90.         'location':'paris',
  91.         },
  92.     }
  94. message=input("Tell me something,and I will repeat it back to you: ")    
  95. #函数input()接受一个参数：即要向用户显示的提示或说明，
  96. #程序等待用户输入，并在用户按回车键后继续运行，输入存储在变量message中
  98. prompt="If you tell us who you are,personalize the message you see."
  99. prompt+="\nWhat is your first name? "
  100. name=input(prompt)
  101. #创建多行字符串，最终的提示横跨2行
  103. %    #求模运算符
  105. while current_number<=5        #while循环
  106.     do something
  108. while True:                    #break,continue
  109.     if test1
  110.         break
  111.     if test2
  112.         continue
  114. unconfirmed_users=['alice','brian','candace']    #在列表之间移动元素
  115. confirmed_users=[]
  116. while unconfirmed_users:
  117.     current_user=unconfirmed_users.pop()
  118.     confirmed_users.append( current_user )
  120. pets=['dog','cat','dog','goldfish','cat','rabbit','cat']    
  121. #删除包含特定值的所有列表元素
  122. while 'cat' in pets:
  123.     pets.remove('cat')

函数：

  1. set()        #创建集合，集合中的每个元素必须是独一无二的
  3. input()        #让程序暂停运行，等待用户输入文本
  5. int()        #将数字的字符串表示转换为数值表示

方法：

  1. user_0.items()        #返回一个键——值对列表
  3. favorite_languages.keys()    #返回一个键列表
  5. favorite_languages.values()        #返回一个值列表，包含重复值

3.函数

将函数存储在模块中：
模块是扩展名为.py的文件

  1. pizza.py    #文件名
  2. def make_pizza( size,*toppings ):
  3.     do something

在文件中导入整个模块：

  1. making_pizzas.py    #文件名
  2. import pizza        
  3. #import语句允许在当前运行的程序文件中使用模块中的代码
  4. pizza.make_pizza( 16,'pepperoni' )    
  5. #调用被导入模块中的函数，
  6. #指定导入的模块的名称pizza和函数名make_pizza(),并用句点分隔

类似于C/C++中的头文件，代码行 import pizza 将文件pizza.py中的所有函数都复制到此程序中

导入特定的函数：

  1. from module_name import function_name    #导入模块中的特定函数
  3. from module_name import function_0,function_1,function_2    
  4. #通过逗号分隔函数名，从模块中导入任意数量函数
  6. from pizza import make_pizza
  7. make_pizza(16,'pepperoni')        
  8. #使用导入特定函数方法，调用函数时无需使用句点，
  9. #由于在import语句中显式地导入了函数,调用时只需指定其名称

使用as给函数指定别名：

  1. from pizza import make_pizza as mp
  2. mp(16,'pepperoni')

使用as给模块指定别名：

  1. import pizza as p
  2. p.make_pizza(16,'pepperoni')

导入模块中的所有函数：

  1. from pizza import *    #使用*运算符可导入模块中的所有函数
  2. make_pizza(16,'pepperoni')

操作：

  1. def greet_user():        #定义函数并调用
  2.     print("Hello!")
  3. greet_user()
  5. def describe_pet(animal_type,pet_name):
  6.     do something
  7. describe_pet('hamster','harry')            #位置实参（基于实参的顺序）
  9. def get_formatted_name( first_name,last_name ):
  10.     full_name=first_name+' '+last_name
  11.     return full_name.title()            #返回值
  13. def get_formatted_name( first_name,last_name,middle_name='' ):    
  14. #可选实参，给可选实参指定默认值为空字符串，并放在形参列表末尾
  15.     if middle_name:
  16.         full_name=first_name+' '+middle_name+' '+last_name
  17.     else:
  18.         full_name=first_name+' '+last_name
  19.     return full_name.title()
  21. def bulid_person( first_name,last_name ):            
  22.     person={
  23.     'first':first_name,'last':last_name}
  24.     return person                                        #返回字典
  26. def greet_users(names):                    #向函数传递列表
  27.     for name in names:
  28.         do something
  29. usernames=['hannah','ty','margot']
  30. greet_users(usernames)
  32. def print_models(unprinted_designs,completed_models):    
  33. #在函数中修改列表，
  34. #这种表示方法使得在函数中对列表所做的任何修改都是永久性的
  35.     while unprinted_designs:
  36.         current_design=unprinted_designs.pop()
  37.         completed_modeles.append( current_design )
  39. def fuction_name( list_name[:] ):        
  40. #向函数传递列表的副本，不对原列表进行修改，
  41. #切片表示法创建[:]创建列表的副本
  42.     do something
  44. def make_pizza( *toppings ):            
  45. #传递任意数量的形参，
  46. #形参名*toppings中的*号将创建一个名为toppings的空元组
  47.     do something
  48. make_pizza('pepperoni')
  49. make_pizza('mushrooms','green peppers','extra cheese')
  51. def make_pizza( size,*toppings ):        
  52. #先匹配位置实参，再将余下的实参都收集到最后一个形参中
  53.     do something
  54. make_pizza( 16,'pepperoni' )
  55. make_pizza( 12,'mushrooms','green peppers','extra cheese')
  57. def bulid_profile( first,last,**user_info ):    
  58. #使用任意数量的关键字实参，允许提供任意数量的名称-值对，
  59. #两个*号创建一个名为user_info的空字典，
  60. #并将收到的所有名称-值对都封装到此字典中
  61.     profile={
  62.     }
  63.     profile['first_name']=first
  64.     profile['last_name']=last
  65.     for key,value in user_info.items():
  66.         profile[key]=value
  67.     return profile
  68. user_profile=bulid_profile( 'albert','einstein',location='princeton',field='physics')

4.类

操作：

  1. class Dog():            #创建类，根据约定，首字母大写的名称指类
  2.     def __init__(self,name,age):        
  3. #每当根据Dog类创建新实例时，该方法都会被自动运行，
  4. #在此方法的名称中开头和末尾均有两个下划线，
  5. #旨在避免默认方法与普通方法发生名称冲突。
  6. #在此方法的定义中，形参self必不可少，且必须位于其他形参之前，
  7. #在调用_init_()方法创建Dog实例时，将自动传入实参self。
  8. #每个与类相关联的方法调用都自动传递实参self，
  9. #它是一个指向实例本身的引用，让实例能访问类中的属性和方法。
  10. #每当根据Dog类创建实例时，都只需给最后两个形参（name 和 age ）提供值
  11.         self.name=name        
  12. #以self为前缀的变量都可供类中的所有方法使用，
  13. #可通过类的任何实例访问这些变量。
  14. #self.name=name获取存储在形参name中的值，并将其存储到变量name中，
  15. #然后该变量被关联到当前创建的实例，这种可通过实例访问的变量称为属性
  16.         self.age=age
  18.     def sit(self):
  19.         print( self.name.title() + "is now sitting." )
  21.     def roll_over(self):
  22.         print( self.name.title() +" rolled over!")
  25. my_dog=Dog('willie',6)        #创建类的实例
  26. print("My dog's name is "+my_dog.name.title()+".")
  27. print("My dog is "+str(my_dog.age)+" years old.")
  28. my_dog.sit()
  29. my_dog.roll_over()
  31. def __init__(self,make,model,year):
  32.     self.odometer_reading=0            #给属性指定默认值
  34. my_new_car=Car('audi','a4',2016)
  35. my_new_car.odometer_reading=23        #直接修改属性的值
  37. def update_odometer( self,mileage ):
  38.     self.odometer_reading=mileage
  39. my_new_car=Car('audi','a4',2016)
  40. my_new_car.update_odometer(23)        #通过方法修改属性的值

继承：
一个类继承另一个类时，它将自动获得另一个类的所有属性和方法;子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法

  1. class Car():
  2.     def __init__(self,make,model,year):
  3.         self.make=make
  4.         self.model=model
  5.         self.year=year
  6.         self.odometer_reading=0
  8. class ElectricCar(Car):        #定义子类，在括号中指定父类的名称
  9.     def __init__(self,make,model,year):    
  10.     #方法_init_()接受创建Car实例所需的信息
  11.         super()._init_(make,model,year)        
  12. #super()将父类和子类关联起来，
  13. #调用父类的方法_init_()让ElectricCar实例包含父类的所有属性
  14.         self.battery_size=70    #子类特有的属性
  16. class ElectricCar(Car):
  17.     def fill_gas_tank(self):    
  18. #对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其重写。
  19. #可在子类中定义一个方法与要重写的父类方法同名。
  20. #这样，python将不会考虑这个父类方法，而只关注在子类中定义的相应方法
  21.         print("This car doesn't need a gas tank!")
  24. class Battery():
  25.     def __init__(self,battery_size=70):
  26.         self.battery_size=battery_size
  27.     def describe_battery(self):
  28.         do something
  29. class ElectricCar(Car):
  30.     def __init__(self,make,model,year):
  31.         super()._init_(make,model,year)
  32.         self.battery=Battery()            #将实例作为属性    
  33. my_tesla=ElectircCar('tesla','model s',2016)
  34. my_tesla.battery.describe_battery()

导入类：

  1. #car.py文件：
  2. class Car():
  3.     do something
  5. #my_car.py文件：
  6. from car import Car        #从模块中导入单个类
  8. #car.py文件：
  9. class Car():        #在一个模块中存储多个类
  10.     do something
  11. class Battery():
  12.     do something
  13. class ElectricCar(Car):
  14.     do something
  16. #my_electric_car.py文件：
  17. from car import ElectricCar
  19. #my_cars.py文件：
  20. from car import Car,ElectricCar        #在一个模块中导入多个类
  22. #my_cars.py文件：
  23. import car        #导入整个模块
  24. my_beetle=car.Car('volkswagen','beetle',2016)    
  25. #使用句点表示法访问需要的类
  27. from modeule_name import*    #导入模块中的所有类
  30. #electric_car.py文件
  31. from car import Car            #在一个模块中导入另一个模块
  32. class Battery():
  33.     do something
  34. class ElectricCar(Car):
  35.     do something

5.文件：

从文件中读取数据：

读取文本文件时，python将其中的所有文本都解读为字符串。若读取的是数字，并要将其作为数值使用，就必须使用函数int() 或 float()进行类型转换
读取整个文件：

  1. with open('pi_digits.txt') as file_object:        
  2. #读取txt文件，函数open()接受一个参数：要打开的文件名称，
  3. #python在当前执行的文件所在的目录中查找指定的文件，
  4. #函数open()返回一个表示文件的对象，关键字with在不再需要访问文件后将其关闭。
  5.     contents=file_object.read()        
  6. #read()读取这个文件的全部内容，
  7. #并将其作为一个长长的字符串存储在变量contents中
  8.     print(contents)        
  9.     #输出最后会有一个空行，
  10.     #因为read()到达文件末尾时返回一个空字符串，
  11.     #而将这个空字符串显示出来就是一个空行
  12.     print( contents.rstrip() )        #rstrip()可删除字符串末尾的空白

使用文件路径：

  1. with open('text_files\filename.txt') as file_object:
  2. #使用相对文件路径，该位置是相对于当前运行的程序所在目录的
  4. file_path='C:\Users\ehmatthes\other_files\text_files\filename.txt'
  5. with open(file_path) as file_object:    #使用绝对路径

逐行读取：

  1. filename='pi_digits.txt'
  2. with open(filename) as file_object:
  3.     for line in file_object:        #利用for循环遍历文件中的每一行
  4.         print(line)        
  5.         #每行的末尾都有一个换行符，输出存在空白行，
  6.         #若需消除空白行，使用rstrip()

创建一个包含文件各行内容的列表：

  1. filename='pi_digits.txt'
  2. with open(filename) as file_object:
  3.     lines=file_object.readlines()    
  4.     #readlines()从文件中读取每一行，并将其存储在一个列表中
  5. for line in lines:
  6.     print(line.rstrip())

使用文件的内容：

  1. filename='pi_30_digits.txt'
  2. with open(filename) as file_object:
  3.     lines=file_object.readlines()
  4. pi_string=''
  5. for line in lines:
  6.     pi_string+=line.strip()

写入文件：

写入空文件：
要将文本写入文件，在调用open()时需提供另一个实参，告知python要写入打开的文件
Python只能将字符串写入文本文件，要将数值数据存储到文本文件中，须先使用str()将其转换为字符串格式

  1. filename='programming.txt'
  2. with open(filename,'w') as file_object:        
  3. #调用open时提供了两个实参，第一个实参为要打开的文件名称；
  4. #第二个实参('w')表示要以写模式打开这个文件。
  5. #（ 读模式'r'，附加模式'a'，读写模式'r+' ，
  6. #若省略模式实参，将以默认的只读模式打开文件）
  7. #若要写入的文件不存在，函数open()将自动创建它。
  8. #以写入'w'模式打开文件时，若指定的文件已存在，将在返回文件对象前清空该文件
  9.     file_object.write("I love programming.")

写入多行：

  1. filename='programming.txt'
  2. with open(filename,'w') as file object:
  3.     file_object.write("I love programming.\n")    
  4.     #要让每个字符串都单独占一行，需在write()语句中包含换行符
  5.     file_object.write("I love creating new games.\n")

附加到文件：
若需给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。以附加模式打开文件时，python不会在返回文件对象前清空文件，而写入到文件的行都将添加到文件末尾。若指定的文件不存在，将创建一个空文件

  1. with open(filename,'a') as file_object:

存储数据：

使用模块json来存储数据
模块json能将简单的python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据

使用json.dump()和json.load():
函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象

  1. #number_writer.py文件
  2. import json
  3. numbers=[2,3,5,7,11,13]
  4. filename='numbers.json'
  5. with open(filename,'w') as f_obj:
  6.     json.dump(numbers,f_obj)
  8. #number_reader.py文件
  9. import json
  10. filename='numbers.json'
  11. with open(filename) as f_obj:
  12.     numebrs=json.load(f_obj)    #使用json.load()将列表读取到内存中
  13. print(numbers)

保存和读取用户生成的数据：

  1. #remember_me.py文件
  2. import json
  3. username=input("What is your name? ")
  4. filename='username.json'
  5. with open(filename,'w') as f_obj:
  6.     json.dump(username,f_obj)
  8. #greet_user.py文件
  9. import json
  10. filename='username.json'
  11. with open(filename) as f_obj:
  12.     username=json.load(f_obj)

发表评论

表情：
评论列表 （有 0 条评论，68人围观）

还没有评论，来说两句吧...

相关阅读