Python 基础API

已于 2022-04-08 18:31:06 修改
阅读量6k 收藏 41
点赞数 6
分类专栏： Python 文章标签： python 开发语言 后端
于 2021-12-27 14:05:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43472877/article/details/122167457
版权

文章目录

零、基本数据类型（数据类型）

| 数值类型（ 整数、浮点数、复数 ）
| 字节类型（ 字符串、字节串 ）
| 集合、元组、列表、字典 |

可变数据类型：list（列表）、dict（字典）、set（集合，不常用）

不可变数据类型：数值类型（int、float、bool）、string（字符串）、tuple（元组）

1、整数类型

  • 与数学中的整数含义相同，无取值范围；
  • 整数包括二进制、八进制、十进制、十六进制等4种表示形式；

二进制：以0b或0B开头：0b1101，-0B10;
八进制：以0o或0O开头：0o456，-0O789;
十进制：123，-321，0；
十六进制：以0x或0X开头：0x1A，-0X2B。


print(1+3)
# 4

2、浮点数

  • 与数学中的实数含义相同，带有小数及小数的数字，存在取值范围；
  • 不确定尾数问题：浮点数直接运算，可能产生不确定尾数。可以使用round()辅助浮点数运算，消除不确定尾数。

print(0.1+0.2111)
# 0.30000000000000004

print(round(0.1+0.2111,5))
# 0.3111

3、复数

  • z = a+bj，a是实部，b是虚部，a和b都是浮点数；

a = 3 + 2j

print(a)
# (3+2j)

print(type(a))
# <class 'complex'>

print(str(a.real) +":" + str(a.imag))
# 3.0:2.0

4、字符串

  • 字符串：由0个或多个字符组成的有序字符序列，由一对单引号(’ ')或一对双引号(" ")表示

5、字节串

  • 字节串是计算机存储空间的表达；
  • 由0个或多个字节组成的有序序列，每字节对应值为0-255；
  • 字节串由前导符b或B与一对单引号或双引号表示，如：b"a\xf6"；
  • 0-255间非可打印字符用\xNN方式表示，N是一个十六进制字符。
  • 什么时候使用字节串？
    字节串只有在处理跟内存相关的内容或者我们处理的内容和字节的数量密切相关的时候才用字节串。

6、组合类型

列表[]、元组()、字典{}

一、python运行代码片段

在这里插入图片描述

>>> print("hello python")
hello python

或者

在这里插入图片描述

二、在Windows系统中从终端运行Python程序

在这里插入图片描述

C:\Users\Administrator\Desktop>python "hello python.py"
hello python

三、变量

message = "hello 变量"
print(message)

在这里插入图片描述

在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

message = "hello 变量"
print(message)

message = "hello 第二个变量"
print(message)

在这里插入图片描述

3.1 变量名

  1. 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为msage_1，但不能将其命名为1_mssage。
  2. 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greelmng_message可行，但变量名greeting message会引发错误。
  3. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
  4. 变量名应既简短又具有描述性。例如，name比n好，stulent_name比s_n好，name_ength比 length_of_persons_name好。慎用小写字母和大写字母O，因为它们可能被人错看成数字1和()。

四、 错误反馈Traceback

message = "hello 第二个变量"
print(mesage)

Traceback (most recent call last):
  File "main.py", line 5, in <module>
    print(mesage)
NameError: name 'mesage' is not defined

Traceback会指出错误行，并且什么地方出错。

五、字符串

字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。

print("string1'hello',hello2")
print('string2')

在这里插入图片描述

5.1 字符串大小写

str1 = "abcd efg"
str2 = str1.title()
print(str2)

在这里插入图片描述

str3 = "Abcd Efg"
print(str3 + "==upper:"+str3.upper())
print(str3 + "==lower:"+str3.lower())

在这里插入图片描述

5.2 合并字符串

str3 = "Abcd Efg"
print("拼接字符串："+str3+""+str3)

在这里插入图片描述

5.3 制表符\t

message1 = "hello python"
message2 = "hello\tpython"
print(message1)
print(message2)

在这里插入图片描述

5.4 换行符\n

message1 = "hello python"
message2 = "hello\tpython"
message3 = "hello\npython"
print(message1)
print(message2)
print(message3)

在这里插入图片描述

5.5 字符串删除空白rstrip()、lstrip()

message1 = "python  "
message2 = "     python  "
print(message1.rstrip()+"!")
print("!"+message2.lstrip()+"!")

在这里插入图片描述

message1 = "python  "
message2 = "     python  "
print(message1.rstrip()+"!")
print("!"+message2.lstrip()+"!")

print("!"+message2.lstrip().rstrip()+"!")
print("!"+message2.lstrip(" ").rstrip(" ")+"!")

在这里插入图片描述

5.6 四则运算

a = 5/2
aa = 5//2
b = 5*2
bb = 5**2
c = 5+2.1
d = 5-6
e = (5-8)**2
print(a)
print(aa)
print(b)
print(bb)
print(c)
print(d)
print(e)

在这里插入图片描述

5.7 str()函数：int型转string 整型转字符型

age = 22
message = "hello" + str(age)
print(message)

5.8 注释

使用 # 号

# age = 22
# message = "hello" + str(age)
# print(message)

六、列表 可变类型 有序

list = ['123','python','java_SE']
print(list)

print(list[0])
print(list[2].title())#首字母大写显示

print(list[-1])#访问最后一个元素

在这里插入图片描述
-2返回倒数第二个元素，-3返回倒数第三个元素，以此类推。

6.1 添加元素、删除元素的几种方式

list = ["java",'mysql','pgsql']
# 末尾添加元素
list.append("python")

# 列中添加元素
list.insert(1,"C++")

# 列中删除元素
del list[1]
print(list)

# 使用pop弹出末尾元素
last = list.pop()
print(last)
print(list)

#使用pop弹出指定位置元素
list.pop(0)
print(list)

#根据值删除元素
list.remove('mysql')
print(list)

在这里插入图片描述

6.2 元素排序list.sort、sorted(list)

words = ["exe","zzz","aAa","ppp"]
# 对列表永排序
words.sort()
print(words) #['aAa', 'exe', 'ppp', 'zzz']

#反序排列
words.sort(reverse=True)
print(words) #['zzz', 'ppp', 'exe', 'aAa']

words_1 = ["exe","zzz","aAa","ppp"]
# 临时排序
print(sorted(words_1)) #['aAa', 'exe', 'ppp', 'zzz']

6.3 反转元素排列顺序list.reverse()

words = ["exe","zzz","aAa","ppp"]
# 永久反转顺序
words.reverse()
print(words) #['ppp', 'aAa', 'zzz', 'exe']

6.4 确认元素长度len(list)

words = ["exe","zzz","aAa","ppp"]
print(len(words)) # 4

6.5 for循环

people = ["小黑","小红","小蓝"]
for i in people:
    print(i)
# 小黑
# 小红
# 小蓝

6.6 range()函数

for value in range(1,5):
    print(value)

    # 1
    # 2
    # 3
    # 4

6.7 最大值和最小值，求和

list = []
for i in range(0,10):
    list.append(i)
print(list) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(max(list)) #9
print(min(list)) #0
print(sum(list)) #45

6.8 列表解析：一行for循环代码

squares = [value**2 for value in range(1,10)]
print(squares) #[1, 4, 9, 16, 25, 36, 49, 64, 81]

6.9 列表：切片

切片：处理列表部分元素。指定要使用的第一个元素和最后一个元素的索引。和range()一样，到达指定索引前一个元素停止。

players = ["james","kevin","irving","love"]

# 取 索引0 到 索引2 的所有元素
print(players[0:3]) # ['james', 'kevin', 'irving']

# 取列表2~4个的元素 ; 索引1 到 索引3 的所有元素
print(players[1:4]) #['kevin', 'irving', 'love']

不指定开始索引，则从列表开头取；反之同理：

# 不指定索引
print(players[:4]) 
#['james', 'kevin', 'irving', 'love']

print(players[1:]) 
#['kevin', 'irving', 'love']

输出列表最后三个元素：

print(players[-3:])
#['kevin', 'irving', 'love']

6.10 遍历切片

for player in players[:3]:
    print(player.title())
# James
# Kevin
# Irving

6.11 复制列表：创建一个无索引切片

players = ["james","kevin","irving","love"]

copyPL = players[:]
print(copyPL) #['james', 'kevin', 'irving', 'love']

players.append("old")
copyPL.append("new")

#证明两者不是

print(players) #['james', 'kevin', 'irving', 'love', 'old']
print(copyPL) #['james', 'kevin', 'irving', 'love', 'new']

七、tuple元组 不可变类型

在这里插入图片描述


# 元组
# 使用（）
dimension = (200, 50)
print(dimension)
print(type(dimension))
# (200, 50)
# <class 'tuple'>

# 不加括号
dimension_1 = 200, 50
print(dimension_1)
print(type(dimension_1))
# (200, 50)
# <class 'tuple'>

# 使用tuple
dimension_2 = tuple((200, 50))
print(dimension_2)
print(type(dimension_2))
# (200, 50)
# <class 'tuple'>

# 单个需要加逗号 不然就是对应类型
dimension_3 = ('sss')
print(dimension_3)
print(type(dimension_3))
# sss
# <class 'str'>


# 元组
dimension = (200,50)
for i in dimension:
    print(i)

相比列表，元组是更简单的数据结构。如果要存储一组值在整个生命周期里不变，可使用元组。

list 是可变的对象，元组 tuple 是不可变的对象。

八、if语句

# if
cars = ['audi','bmw','subaru']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.lower())
# audi
# BMW
# subaru

8.1 if-else：

age = 17
if age>=18 :
    print(age)
else:
    print("too young")
#too young

8.2 if-elif-else:

age = 17
if age<18:
    print("too young")
elif age == 18:
    print("just enough")
else:
    print("right")
# too young

8.3 多个elif：

age = 12
if age < 10:
    price = 1
elif age > 10 and age < 15:
    price = 2
elif age > 15:
    price = 3
else:
    price = 4
print(price) #2

8.4 pass语句

在这里插入图片描述

a = 10
if a == 10:
    pass
else:
    pass

九、条件判断：等号=、==；不等于!=；大于等于>=；小于等于<=；多个条件and；或or；

一个等号是陈述，两个等号是发问返回True和False。

判断时会判定大小写不同。若大小写无影响，可转换大小写进行比较。

car = 'bmw';
print(car == 'bmw') #True
print(car == 'BMW') #False

判断两个值不同：!=

and将两个条件测试合二为一，每个表达式都通过，则为True；

or只要有一个语句满足条件，则为True。所有条件不满足，表达式为False；

9.1 in 检查特定值是否包含在列表中

example = ('abs','AAA','K','3A')
print('AAA' in example) #True

十、dict字典 可变类型 无序

在这里插入图片描述
在这里插入图片描述

10.0 字典的获取：


aliens = {'color': 'red', 'points': '5'}

#[]方法
print(aliens['color']) #red
print(aliens['points']) #5

# get方法
print(aliens.get('color'))
# red

10.1 添加键值对

aliens = {'color':'red','points':'5'}

aliens['hight'] = 30
aliens['weight'] = 1000

print( aliens )
# {'color': 'red', 'points': '5', 'hight': 30, 'weight': 1000}

10.2 删除键值对

aliens = {'color':'red','points':'5'}

aliens['hight'] = 30
aliens['weight'] = 1000
print( aliens )
# {'color': 'red', 'points': '5', 'hight': 30, 'weight': 1000}

del aliens['weight']
print( aliens )
# {'color': 'red', 'points': '5', 'hight': 30}

10.3 修改键值对

aliens = {'color':'red','points':'5'}
aliens['color'] = 'yellow'
print( aliens )
# {'color': 'yellow', 'points': '5'}

10.4 遍历字典 ：

user = {"username":"kevin",
        "age":"22",
        "gender":"male"}

for key,value in user.items():
    print("key:"+key+" value:"+value)
# key:username value:kevin
# key:age value:22
# key:gender value:male

10.5 .keys()方法

user = {"username":"kevin",
        "age":"22",
        "gender":"male"}
# 获取keys
for i in user.keys():
    print(i)
# username
# age
# gender

aliens = {'color': 'red', 'points': '5'}

for i in aliens:
    print(i, aliens[i], aliens.get(i))
# color red red
# points 5 5

10.6 .values() 方法

user = {"username":"kevin",
        "age":"22",
        "gender":"male"}

for i in user.values():
    print(i)
# kevin
# 22
# male

10.7 .items()方法 转换后获得元组

for i in aliens.items():
    print(i)
    for j in i:
        print(j)

# ('color', 'red')
# color
# red
# ('points', '5')
# points
# 5

10.8 zip() 字典生成式

在这里插入图片描述

keys = ['books', 'tools']
price = [11, 21, 31]

for i in zip(keys, price):
    print(i)
# ('books', 11)
# ('tools', 21)

for k, p in zip(keys, price):
    print(k, p)
# books 11
# tools 21

10.9 字典列表嵌套

alien_o = {'color': 'green ', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red ', 'points': 15}
aliens = [alien_o, alien_1, alien_2]
for alien in aliens:
    print(aliens)
    
# [{'color': 'green ', 'points': 5}, {'color': 'yellow', 'points': 10}, {'color': 'red ', 'points': 15}]
# [{'color': 'green ', 'points': 5}, {'color': 'yellow', 'points': 10}, {'color': 'red ', 'points': 15}]
# [{'color': 'green ', 'points': 5}, {'color': 'yellow', 'points': 10}, {'color': 'red ', 'points': 15}]


print(type(aliens))
# <class 'list'>

10.10 字典列表

切片打印前五个

aliens = []
for alien in range(30):
    new_alien = {'color':'red ', 'points':15}
    aliens.append(new_alien)

for alien in aliens[:5]:
    print(alien)
print("...")

# {'color': 'red ', 'points': 15}
# {'color': 'red ', 'points': 15}
# {'color': 'red ', 'points': 15}
# {'color': 'red ', 'points': 15}
# {'color': 'red ', 'points': 15}
# ...

10.11 字典中储存列表

example = {
    "user":["james","kevin","tom"],
    "password":"123456"
}
print(example["user"]) #['james', 'kevin', 'tom']
print(example["password"]) #123456

10.12 字典中存储字典

example = {
    "example_1" : {"user":["james","kevin","tom"],"password":"123456"},
    "example_2" : ["list1","list2","list3"],
    "example_3" : "example_3"
}
print(example)
#{'example_1': {'user': ['james', 'kevin', 'tom'], 'password': '123456'}, 'example_2': ['list1', 'list2', 'list3'], 'example_3': 'example_3'}
print( example["example_1"])
#{'user': ['james', 'kevin', 'tom'], 'password': '123456'}

十一、set集合 可变类型 无序 不能重复

在这里插入图片描述
在这里插入图片描述

11.1 集合创建

# 使用{}
s = {1, 23, 4, 345, 1, 2, 2}
print(s, type(s))
# {1, 2, 4, 23, 345} <class 'set'>

# 使用set()
s1 = set(range(5))
print(s1, type(s1))
# {0, 1, 2, 3, 4} <class 'set'>

language = {"james":"c++",
            "kevin":"python",
            "bob":"java",
            "lily":"python"}

for i in set(sorted(language.values())):
    print(i)
# python
# java
# c++

11.2 集合相关操作

在这里插入图片描述


ss = {123, 123, 1, 4, 124, 2}

print(ss)
# {1, 2, 4, 123, 124}

print(123 in ss)
# True

ss.add("11")
print(ss)
# {1, 2, '11', 4, 123, 124}

ss.update({"22", "222", "2222"})
print(ss)
# {'222', 1, 2, '22', 4, '11', '2222', 123, 124}

11.3 集合间的关系

在这里插入图片描述


# 两个集合是否相等 元素相同就相同
s = {10, 20, 30, 40, 50}
s1 = {40, 30, 20, 10, 50}
print(s == s1)
# True

# 判断子集
s2 = {10, 20}
print(s2.issubset(s))
# True

s3 = {10, 21, 22}
print(s3.issubset(s))
# False

# 判断超集
print(s1.issuperset(s2))
# True

print(s3.issuperset(s2))
# False

# 交集
print(s2.isdisjoint(s1))
# False 有交集为False

十二、用户输入input()

name = input()
print(name)

Python2.7，应使用函数raw input()来提示用户输入。这个函数与Python3中的input ()一样，也将输入解读为字符串。

sentence = "hello please inuput:"
message = ""
message = input(sentence)
print(message)

# hello please inuput:dwadaw
# dwadaw

十三、while循环

current_num = 1
while current_num <= 5:
    print(str(current_num) + " ", end = "")
    current_num+=1
    
# 1 2 3 4 5

python 3.x版本输出不换行格式如下

print(x, end=“”) end=“” 可使输出不换行。

# 使用while循环，当输入exit才停止 
sentence = "Display entered:"
message = input("input message - exit or others :\n")
while message != "exit":
    message = input(sentence + message)
    print(message)

# input message - exit or others :
# hello
# Display entered:hello
# 
# Display entered:abc
# abc
# Display entered:abc
# 
# Display entered:exit
# exit

13.1 while中使用标志

# while中使用标志  当flag不为True时，停止while循环
sentence = "Display entered:"
message = input("input message - exit or others :\n")
flag = True
while flag:
    if message != "exit":
        message = input(sentence + message)
        print(message)
    else:
        flag = False

13.2 while 使用break 退出循环

# 使用break 退出循环
falg = True
variable1 = 1
while falg:
    if variable1 <=5:
        print(variable1 , end = "")
        variable1 += 1
    else:
        break
 # 12345

13.3 while使用continue

# 循环中使用 continue
current_number = 0
while current_number <10:
    current_number += 1
    if current_number % 2 ==0:
        continue #跳过本次，执行后面代码
    print(current_number, end="") #13579

13.4 while循环处理列表和字典

处理列表

#验证账户
while unconfirmed:
    current = unconfirmed.pop()
    print("verifying : "+current.title())
    confirmed.append(current)

print("unconfirmed:")
for i in unconfirmed:
    print(i.title())

print("all confirmed:")
for i in confirmed:
    print(i.title())

# verifying : Tom
# verifying : Kevin
# verifying : James
# unconfirmed:
# all confirmed:
# Tom
# Kevin
# James

#删除包含特定值的所有列表元素
pets = [ "dog","cat","dog","goldfish","cat","rabbit","cat" ]
print(pets)

while "cat" in pets:
    pets.remove("cat")

print( pets)

# ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
# ['dog', 'dog', 'goldfish', 'rabbit']

处理字典

# 使用用户输入填充字典
rs_responses = {}
flag = True

while flag:
    name = input("what's your name?")
    response = input("what's your favorite weather?")
    # 存进字典
    rs_responses[name] = response

    repeat = input("would you like to continue? yes/no")
    if repeat == "no":
        flag = False

print( rs_responses )

# what's your name?james
# what's your favorite weather?daylight
# would you like to continue? yes/noyes
# what's your name?kevin
# what's your favorite weather?rainday
# would you like to continue? yes/nono
# {'james': 'daylight', 'kevin': 'rainday'}

十四、函数

14.1 简单函数

# 问候语简单函数
def greet_user():
    print("hello!")

greet_user() #hello!

def greet_user(username):
    print("hello!" + username.title() + "!")

greet_user("tom")  #hello!Tom!

14.2 函数形参与实参赋值

def describe_pet(animal_type, pet_name):
    print("I have a " + animal_type)
    print("My " + animal_type + " name is " + pet_name)
describe_pet("dog", "wangwang")

#I have a dog
# My dog name is wangwang

def describe_pet(animal_type, pet_name):
    print("I have a " + animal_type)
    print("My " + animal_type + " name is " + pet_name)

describe_pet(pet_name="wangwang", animal_type="dog")

#I have a dog
#My dog name is wangwang

14.3 形参默认值

def describe_pet(pet_name, animal_type="dog"):
    # def describe_pet(animal_type="dog",pet_name):  报错
    print("My " + animal_type + " name is " + pet_name)

describe_pet(pet_name="wangwang")
# My dog name is wangwang

14.4 函数返回值

使用return语句返回值到调用函数代码行

def get_formatted_name(first_name,last_name):
    full_name = first_name+" "+last_name
    return  full_name.title()

worker = get_formatted_name("tom","kin")
print(worker) #Tom Kin

14.5 实参可选

def get_formatted_name(first_name, last_name, middle_name=""):
    if middle_name:
        full_name = first_name + " " + middle_name + " " + last_name
    else:
        full_name = first_name + " " + last_name
    return full_name.title()


worker = get_formatted_name("tom", "kin")
print(worker)  # Tom Kin
worker2 = get_formatted_name("tom", "kin", "ray")
print(worker2)  # Tom Ray Kin

14.6 返回字典

函数可以返回任何值，包含字典与数据结构；

# 返回字典
def build_person(first_name, last_name):
    person = {'first': first_name, 'last': last_name}
    return person

worker = build_person("will", "smith")
print(worker) #{'first': 'will', 'last': 'smith'}

14.7 结合函数使用while循环

# 结合函数使用while循环
def get_username(first_name, last_name):
    full_name = first_name + " " + last_name
    return full_name.title()


while True:
    print("please input your name: enter q or others to quit; y to continue")
    variable = input("input your choice:")

    if variable == "y":
        first_name = input("please input your first name:")
        last_name = input("please input your last name:")
        rs = get_username(first_name, last_name)
        print(rs.title())
    else:
        break
# please input your name: enter q or others to quit; y to continue
# input your choice:y
# please input your first name:yh
# please input your last name:l
# Yh L
# please input your name: enter q or others to quit; y to continue
# input your choice:q

14.8 函数传递列表

# 传递列表
def get_username(names):
    #     向列表每个元素都发出简单问候
    for i in names:
        msg = "hello " + i.title()
        print(msg)


users = ['james', 'tom', 'kevin']
get_username(users)

# hello James
# hello Tom
# hello Kevin

14.9 函数修改列表

# 函数修改列表
users = ['tom', 'james', 'kevin']
temp_list = []


# 模拟交换每个用户
def change_user(original_list, rs_list):
    while users:
        temp_variable = original_list.pop()
        print("user :" + temp_variable)
        rs_list.append(temp_variable)


def show_users(rs_list):
    print(rs_list)


change_user(users, temp_list)
show_users(temp_list)

14.10 禁止函数修改列表

使用切片，相当于传值给一个临时变量 change_user(users[:], temp_list) ，user[]内容将不会被pop。

# 禁止函数修改列表
users = ['tom', 'james', 'kevin']
temp_list = []


def change_user(original_list, rs_list):
    while original_list:
        temp_variable = original_list.pop()
        print("user :" + temp_variable)
        rs_list.append(temp_variable)


def show_users(rs_list):
    print(rs_list)


# 使用切片
change_user(users[:], temp_list)

show_users(users)
show_users(temp_list)

# user :kevin
# user :james
# user :tom
# ['tom', 'james', 'kevin']
# ['kevin', 'james', 'tom']

14.11 传递任意数量实参

预先不知道函数需要接受多少个实参

def print_users(*user):
    print(user)


customer_1 = ["example1"]
customer_2 = ["example1", "example2", "example3"]

print_users(customer_1)  # (['example1'],)
print_users(customer_2)  # (['example1', 'example2', 'example3'],)

*user创建一个空元组

结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。

def make_pizz(size, *type):
    for i in type:
        print(str(size) + i)


make_pizz(1, 'a')
make_pizz(3, 'a', 'b', 'c')
# 1a
# 3a
# 3b
# 3c

使用任意数量的关键字实参

**user_info两个星号让python创建一个user_info的空字典，并将收到的所有键值对都装到这个字典；

# ** 创建字典
def build_profile(firstname, lastname, **user_info):
    profile = {}
    profile['firstname'] = firstname
    profile['lastname'] = lastname
    for key, value in user_info.items():
        profile[key] = value
    return profile


user_profile = build_profile('james', 'kevin', place="China", fild="physics")
print(user_profile)

14.12 函数存储到模块

创建一个python文件，pizza.py

def make_pizza(size, *toppings):
    """概述要执着的披萨"""
    print("\nMaking a " + str(size) + "inch pizza")
    for i in toppings:
        print("-" + i)

同级目录中main.py 导入模块

import pizza

pizza.make_pizza(16, "pepperoni")
pizza.make_pizza(12, "chicken", "green pepper")

# Making a 16inch pizza
# -pepperoni
# 
# Making a 12inch pizza
# -chicken
# -green pepper

14.13 导入特定函数

from module_name import function_0,function_1,functrion_2

创建一个python文件，pizza.py

def make_pizza(size, *toppings):
    """概述要执着的披萨"""
    print("\nMaking a " + str(size) + "inch pizza")
    for i in toppings:
        print("-" + i)


def make_pizza_1(size,*topping):
    print("另外一个函数")

同级目录中main.py 导入模块

from pizza import make_pizza,make_pizza_1
make_pizza(16, "pepperoni")
make_pizza_1(12, "chicken", "green pepper")

# Making a 16inch pizza
# -pepperoni

# 另外一个函数

14.14 as给函数指定别名

给make_pizza 指定别名mp()

# as指定函数别名
# 给make_pizza 指定别名mp()
from pizza import make_pizza as mp

mp(16, "pepperoni")
# Making a 16inch pizza
# -pepperoni

14.15 as给模块指定别名

import  module_name as m

# 使用as 给模块取别名
# import  module_name as m
import  pizza as p
p.make_pizza(11,"green pepper")

# Making a 16inch pizza
# -pepperoni

14.16 导入函数中所有函数

使用星号（*）运算符可让Python导入模块中的所有函数:

pizza.py

def make_pizza(size, *toppings):
    """概述要执着的披萨"""
    print("\nMaking a " + str(size) + "inch pizza")
    for i in toppings:
        print("-" + i)


def make_pizza_1(size,*topping):
    print("另外一个函数")

main.py

from pizza import  *
make_pizza(11,"11")
make_pizza_1(22,"22")

# Making a 11inch pizza
# -11

# 另外一个函数

十五、类

1、创建和使用类

创建小狗类：

class Dog:
#class Dog(): 这样定义类也可以
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(self.name.title() + " sit down")

    def roll_over(self):
        print(self.name.title + " rolled over")

1、方法__init__

类中的函数称为方法

方法__init__是一个特殊的方法，每当你根据dog类创建新实例时，Pyton都会自动运行它。

在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Pytiomn默认方法与普通方法发生名称冲突。
我们将方法__init__定义成了包含三个形参: self、 name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self呢?因为Pythom调用这个__init__方法来创建dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。我们创建dog实例时，Python将调用dog类的方法__init__。我们将通过实参向dog ()传递名字和年龄，self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最后两个形参(name和age 〉提供值。

class Dog():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(self.name.title() + " sit down")

    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() + ", age " + str(my_dog.age))
# my dog's name is Willie, age 6

my_dog.sit()  # Willie sit down
my_dog.roll_over()  # Willie rolled over

your_dog = Dog("james", 2)
your_dog.sit()
your_dog.roll_over()
# James sit down
# James rolled over

2、给属性指定默认值

# 指定默认值
class Car():
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        # 添加一个属性 始终为0
        self.test = 0

    def get_descript_car(self):
        longname = self.make + self.model + str(self.year)
        return longname

    def read_test(self):
        print("car mileage is " + str(self.test))


my_new_car = Car("audi", "a4", 2016)
my_new_car.read_test()  # car mileage is 0

3、修改属性值

# 指定默认值
class Car:
#class Car():  这样定义类也可以
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        # 添加一个属性 始终为0
        self.test = 0

    def get_descript_car(self):
        longname = self.make + self.model + str(self.year)
        return longname

    def read_test(self):
        print("car mileage is " + str(self.test))

    # 方法修改属性值
    def update_test(self, mileage):
        self.test = mileage

    # 方法递增
    def increment_test(self, miles):
        self.test += miles


my_new_car = Car("audi", "a4", 2016)
my_new_car.read_test()  # car mileage is 0

# 1、直接修改属性值
my_new_car.test = 22
my_new_car.read_test()  # car mileage is 22

# 2、通过方法修改属性值
my_new_car.update_test(50)
my_new_car.read_test()  # car mileage is 50

# 3、通过方法对属性值进行递增 有时候需要将属性值递增特定的量，而不是将其设置为全新的值。
my_new_car.increment_test(99)
my_new_car.read_test()  # car mileage is 149

3、继承

编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用继承。

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法，原有的类称为父类，而新类称为子类。

子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

# 模拟汽车
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.mileage = 0

    def get_car(self):
        print(self.make + " " + self.model + " " + str(self.year) + " : " + str(self.mileage) + " mileage")

    def read_mileage(self):
        print(self.mileage)

    def update_mileage(self, mile):
        if mile > self.mileage:
            self.mileage = mile
        else:
            print("can't roll back mileage")

    def increment_mileage(self, mile):
        self.mileage += mile


# 模拟电动汽车
class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)


my_tesla = ElectricCar("tesla", "model s", 2016)
my_tesla.get_car()  # tesla model s 2016 : 0 mileage

给子类定义属性和方法

# 模拟汽车
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.mileage = 0
        self.gas = 100

    def get_car(self):
        print(self.make + " " + self.model + " " + str(self.year) + " : " + str(self.mileage) + " mileage")

    def read_mileage(self):
        print(self.mileage)

    def update_mileage(self, mile):
        if mile > self.mileage:
            self.mileage = mile
        else:
            print("can't roll back mileage")

    def increment_mileage(self, mile):
        self.mileage += mile

    def fill_gas_tank(self):
        print("car gas tank : " + str(self.gas))


# 模拟电动汽车
class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        # 子类定义属性
        self.batter_size = 100

    # 定义子类特定的方法
    def describe_battery(self):
        # 容量
        print("capacity : " + str(self.batter_size))

    # 重写fill_gas_tank
    def fill_gas_tank(self):
        print("electricCar dont need gas tank")


# 继承
my_tesla = ElectricCar("tesla", "model s", 2016)
my_tesla.get_car()  # tesla model s 2016 : 0 mileage

# 定义子类特定的方法
my_tesla.describe_battery()  # capacity : 100

重写父类方法

# 模拟汽车
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.mileage = 0
        self.gas = 100

    def get_car(self):
        print(self.make + " " + self.model + " " + str(self.year) + " : " + str(self.mileage) + " mileage")

    def read_mileage(self):
        print(self.mileage)

    def update_mileage(self, mile):
        if mile > self.mileage:
            self.mileage = mile
        else:
            print("can't roll back mileage")

    def increment_mileage(self, mile):
        self.mileage += mile

    def fill_gas_tank(self):
        print("car gas tank : " + str(self.gas))


# 模拟电动汽车
class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        # 子类定义属性
        self.batter_size = 100

    # 定义子类特定的方法
    def describe_battery(self):
        # 容量
        print("capacity : " + str(self.batter_size))

    # 重写fill_gas_tank
    def fill_gas_tank(self):
        print("electricCar dont need gas tank")


# 继承
my_tesla = ElectricCar("tesla", "model s", 2016)
my_tesla.get_car()  # tesla model s 2016 : 0 mileage

# 定义子类特定的方法
my_tesla.describe_battery()  # capacity : 100

# 重写父类方法
my_tesla.fill_gas_tank() # electricCar dont need gas tank

4、导入类

导入单个类

from car import Car

import语句让Python打开模块car.py ，并导入其中的Car类。

一个模块中存储多个类

ElectricCar.py

# 模拟汽车
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.mileage = 0
        self.gas = 100

    def get_car(self):
        print(self.make + " " + self.model + " " + str(self.year) + " : " + str(self.mileage) + " mileage")

    def read_mileage(self):
        print(self.mileage)

    def update_mileage(self, mile):
        if mile > self.mileage:
            self.mileage = mile
        else:
            print("can't roll back mileage")

    def increment_mileage(self, mile):
        self.mileage += mile

    def fill_gas_tank(self):
        print("car gas tank : " + str(self.gas))


# 模拟电动汽车
class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        # 子类定义属性
        self.batter_size = 100

    # 定义子类特定的方法
    def describe_battery(self):
        # 容量
        print("capacity : " + str(self.batter_size))

    # 重写fill_gas_tank
    def fill_gas_tank(self):
        print("electricCar dont need gas tank")

新建一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车了:

from ElectricCar import ElectricCar

my_tesla = ElectricCar('tesla', 'model', 2021)

my_tesla.get_car()  # tesla model 2021 : 0 mileage

从一个模块导入多个类

from ElectricCar import Car, ElectricCar

导入整个模块

你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。

import car

my_tesla = car.Car("audi", "a4", 2021)
print(my_tesla.get_descript_car())  # audia42021

导入模块中的所有类

from module_name import *

5、Python标准库 collections类OrderedDict

from collections import OrderedDict

favorite_language = OrderedDict()

favorite_language['jen'] = 'python'
favorite_language['sarah'] = 'java'
favorite_language['tom'] = 'ruby'
favorite_language['phil'] = 'python'

for name, language in favorite_language.items():
    print(name.title() + "'s favorite language is " + language.title() + ".")

# Jen's favorite language is Python.
# Sarah's favorite language is Java.
# Tom's favorite language is Ruby.
# Phil's favorite language is Python.

蓝色。通过组合不同的RGB值，可创建1600万种颜色。在颜色值(230, 230, 230)中，红色、蓝色和绿色量相同，它将背景设置为一种浅灰色。

_七七
关注
  • 6
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python------API
m0_64365419的博客
08-06 953
Git和GitHub;使用API调用请求资源；Requests包的有关内容；处理API响应的步骤和方法；处理响应字典；使用Plotly可视化GitHub网站上的Python项目仓库；添加自定义工具提示；在图表中添加可单击的链接；...
python百度百科api-python使用API
weixin_37988176的博客
11-01 2444
本人从2017年4月初开始学习python,截至到6月13号学习python已经有2.5个月了，这段时间以来学习了搭环境、变量、列表、If、字典、while循环、函数、类、处理文件、测试代码等,接下来将学习API调用。API：Web应用编程接口（API）自动请求网站的特定信息而不是整个网页。因此即便数据瞬息万变，它呈现的信息也都是最新的。17.1 使用Web APIWeb API是网站的一部分，用...
Python API教程：API入门
wbryze的博客
03-06 5357
json软件包是标准库的一部分，无需额外安装即可使用，即可以将列表和字典转换为JSON，也可以将字符转换为列表和字典。许多API都需要登录证书，因此当您没有发送正确的证书来访问API时，就会发生这种情况。当我们发起请求，API通常会返回我们返回的编码，告诉是否请求成功。一个API，或被称为应用程序接口，是一个服务器为你提供一个接收或发送数据的代码。API请求工作都遵循类似的路径，你发布一个请求到一个API服务器，它返回给你请求的数据。这是我们第一个API请求，使用GET请求数据，这种方法也是常见的操作。
python 常用API
lbaihao的专栏
05-08 1472
1.在程序开发中，常常会遇到这样的需求：在执行对象中的某个方法，或者在调用对象的某个变量，但是由于一些原因，我们无法确定或者并不知道该方法或者变量是否存在，这时我们需要一个特殊的方法或者机制来访问或操作该未知的方法或变量，这种机制就被称之为反射。 ...
Python实战 | 如何使用 Python 调用 API
最新发布
WBKJ_Noah的博客
04-05 1984
本文介绍了 API 是如何实现访问外部数据和功能的，也对 HTTP 协议以及两个常用的请求方式——GET 请求和 POST 请求做了简单介绍，然后通过两个例子演示了如何利用 Python 中的 requests 库实现 API 的调用，并解析返回的响应结果来获得相应的内容，也向大家展示了两种请求方式的异同点，希望对大家有所帮助。
python——使用API
一只养生的程序猿。
06-26 6807
python-Web API及数据可视化处理
利用Python编写和使用API的完全指南
h1874696607的博客
07-09 1709
利用Python编写和使用API为开发人员提供了广阔的机会，可以轻松地实现不同系统之间的数据交换和功能共享。通过理解API概念、安装必要的库、使用Python进行API请求、构建API服务器、解析和处理API响应等步骤，您可以成为一个熟练的API开发者。无论是创建自己的API还是使用现有的API，Python都是一个强大的工具，可以加快开发速度并提高效率。希望本文能为您提供关于利用Python编写和使用API的完全指南，并帮助您在日常开发中更好地利用API的优势。首先，我们需要了解API的基本概念。
python api接口开发教程_Python-接口开发入门解析
weixin_39530149的博客
11-29 1247
一、开发接口的作用1、mock接口：模拟一些接口。有一些有关联的接口，在别的接口没有开发好的时候，需要用这个接口，就可以写一个假接口，返回想要的结果来模拟这个接口。2、知道服务端的开发逻辑，有助于测试；3、比如不想让其他人看很多数据库中的数据，可以通过接口只返回一部分数据。二、开发一个接口1、flask是一个轻量级的开发框架__name__：代表当前这个python文件server = flask...
python实现API的调用
m0_67402970的博客
08-02 1万+
其实最近发现博客很久没更新，可能还是因为自己懒以及能力有限不知道该写什么，但上半年工作以及生活中发现，写作其实是一个很好的东西，可以把自己的想法记录下来，虽然可能很不成熟，但是其实对于自己的成长是很有帮助，写多了也就熟了，而且现在快餐式的互联网，让我们中断了很多思考，尤其是工作后发现，平常还是要多思考，多写作，也可以沉淀自己，后续会慢慢更新博客，但是频率可能不是很高，但是会慢慢多加入自己的思考和逻辑以及一些归纳，因为发现之前的博客太不成熟了哈哈哈。httpshttpshttps。...
python调用api.docx
12-08
- Python编程基础 - `requests`库的使用，用于发送HTTP请求 - JSON数据格式处理，用于构建和解析API请求及响应 - OpenStack API的使用，了解不同资源（如用户、网络、子网等）的创建方法 - Token机制，理解OpenStack...
Python基础教程 api
01-26
Python基础教程 api 好吧，就这样吧 好吧，就这样吧好吧，就这样吧
pythonAPI文档
04-25
python API 文档 参考 官方 备份 学习
python调用api
07-25
python调用api代码。实现api的调用，参数的设置、返回信息的处理等。
python语法api
11-29
python语法参考，包含python基础api，关键是小放在桌面上随时参考。
Arcgis API for Python技术基础视频
03-14
关于Arcgis API for Python基础技术视频.，运行环境、基础功能模块及简单分析应用分享
python中文api文档+学习笔记
07-20
python的中文api文档，还有学习python的基础笔记，就是这些了
Python实现简单的API
热门推荐
树洞
07-12 2万+
get方法代码实现# coding:utf-8import json from urlparse import parse_qs from wsgiref.simple_server import make_server # 定义函数，参数是函数的两个参数，都是python本身定义的，默认就行了。 def application(environ, start_response): # 定义文
Python 常用Api
n1355553344的博客
08-22 209
URL编码 from urllib import quote quote('') #URL encode unquote(''.encode('utf-8')) #URL decode webdriver 安装webdriver，添加进系统环境变量 基本操作如下： #打开浏览器 driver = webdriver.Chrome("C:\\dev-softwares\\webdriver\\chromedriver.exe") #用浏览器发送请求 driver.get(url) 解析driver指代
Python API
10-21
Python API是指Python编程语言提供的一组接口，用于与其他应用程序或服务进行交互。Python API可以让开发者通过编写Python代码来调用其他应用程序或服务的功能，例如发送HTTP请求、访问数据库、操作文件等。Python API通常使用第三方库来实现，例如上文提到的Request库。Python API的使用可以大大简化开发者的工作，提高开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值