Python学习1.0基础知识教学
一、两种使用方法
控制台
软件(如pycharm)
二、基础语法
1.变量
变量前加上 global关键字，会变为全局变量
x = “name” (直接定义即可，约定俗成：驼峰 newUserName)
MyJob = "teacher"
player1 = “”姚 明“”
player1_score = 41
2.数据类型
整数，浮点数，布尔（true，false），字符串（0，none，空字符串转换为布尔值后为false）
int(9.9) 9
round(9.9) 10
round(3.141564,2) 3.14
3.算数运算符
1. + - * /
2. //(除法取整符号) print(5 / 2) 2.5
print(5 // 2) 2
3. %（取模运算 eg:a%b = a-(a//b)*b）,正数的取模和取余数一样 print(7 % 4) 3
print(-7 % 4) 1
4. 字符串支持+ *运算，不支持- /运算 print("hello " + "koko") hello koko
print("ko" * 10) kokokokokokokokokoko
print("您的账户余额为：" + str(500)) 您的账户余额为：500
5. 书写运算符两边要有空格
4.赋值运算符
ko = 0
1. += -= (加法，减法赋值运算符) print（ko += 10） 10
2. *= /= //= （乘法，除法，取整除赋值运算符）
3. %= **= （取模，幂赋值运算符）
5.比较运算符
== 等于 !=不等于 >大于 <小于 >=大于等于 <=小于等于（输出true false）
6.逻辑运算符
and 与 or 或 not 非（走完一部分逻辑成立就不会走剩下的部分，直接输出已走完部分的结果）
a=10
a>20 and a<90 false
a>20 or a<90 true
not a>20 true
not a<20 false
7.条件判断 if elif else
python里面没有{}的表示形式，表达包含关系需缩进4个空格(pycharm按Tab键即可)
score = 89
if score >= 68 and score <= 100:
# pass（可作为占位符）
if score < 78 :
print("成绩合格")
elif score >= 98 :
print("成绩优秀")
else:
print("成绩良好")
else:
print("成绩不合格")
8.循环 for 循环 while
打印9 9乘法表
for i in range(1,10): ----- range返回10前从1开始的数字1-9
for j in range(1，i+1): ----- 先执行的放内层
print(str(i) + "*" + str(j) + "=" + str(i*j), end= " ")
----- end为换行符，放入空字符串，打印的数据放进同一行
print() ----- 换行
break continue
lap = 0
total = 0 ----- 一定写在外面，写在循环里会被多次循环覆盖
while lap < 8:
lap += 1
if lap % 2 == 0:
continue ----- 跳出第二圈的循环，直接执行第三圈
total += lap
print("跑完了第" + str(lap) + "圈")
if lap == 5:
break ----- 第五圈循环结束直接跳出，其余循环不执行
print("共计跑完了" + str(total) + "圈")
小节练习：智能密码锁
密码锁逻辑：一大段密码中只要包含真实密码就能打开大门
123456
4567865451234564654
password = '123456'
failed_time = 0
while True: -----死循环
pwd = input("请设置您的密码:\n") ----- \n为换行符
if not pwd:
break
confirm_pwd = input("请再次输入您的密码:\n")
if pwd == confirm_pwd:
password = pwd
break
print("您两次输入的密码不一致，请重新输入")
print("您的初始密码已设置为",password)
print("进入开锁程序")
while True:
input_pwd = input("请输入您的密码:\n")
if password in input_pwd: ----- 关键：查看password是否在input_pwd里
print("开锁成功")
break
else:
failed_time += 1
if failed_time >= 3:
print("输入错误3次以上，密码已锁定")
break
print("您输入的密码有误，请重新输入")
三、数据结构
1.数字格式化
| 占位符写法 | 作用 |
|---|---|
| %d | 整数占位符（取整无四舍五入） |
| %f | 浮点数占位符 |
| %.f | 指定精度的浮点数占位符 %.2f %.4f（不足指定精度会往后面补0） |
| %s | 字符串占位符（什么都能传，整数，浮点数等等） |
| %% | 特殊符号，输出% |
| str.format() | 数字格式化函数，通过 : 来代替 % |
lap = 3.1
print("%d（整数占位符会取整）" % lap) ----- 此处执行为3
print("%f（浮点数占位符默认小数点后6位，不足会补0，超了会截掉）" % 3.1415) ----- 此处执行为3.141500
print("%.2f（传整数也会自动转为浮点数）" % 3.141592) ----- 此处执行为3.14
str.format() 格式化数字的多种方法
s = "{0}的国家今年总收入金币{1:,}枚，这{1:}枚全部被{0}挥霍掉了".format("苏丹",1534312313)
print(s)
-----苏丹的国家今年总收入金币1,534,312,313枚，这1534312313枚全部被苏丹挥霍掉了
2.字符串格式化
| 格式化方法 | 作用 |
|---|---|
| %s | 字符串占位符（什么都能传，整数，浮点数等等） |
| str.format() | 字符串格式化函数，通过 {} 来代替 % |
%s字符串占位符的使用
print("看到这里的都%s" % "暴富") -----只想发财的作者
str.format() 格式化字符串的多种方法
- 方法一：在format里直接设置参数
print("姓名：{name},年龄：{age}".format(name="流氓", age=18))
- 方法二：通过字典设置参数
site={"name":"流氓","age":18,"sex":"男"}
print("姓名：{name},年龄：{age},性别：{sex}".format(**site))
- 方法三：通过列表索引设置参数
site=["流氓","男",18]
print("姓名：{0[0]},年龄：{0[2]},性别：{0[1]}".format(site)) -----"0" 是必须的
- 方法四：可向 format里传入对象
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) -----"0" 是可选的
- 方法五：format 函数可以接受不限个参数，位置可以自己用数组下标设置
print("{1} {0} {1}".format("hello", "world")) -----用数组下标设置指定位置 'world hello world'
3.字符串索引与切片
s = “kokoamber”
----- 0123 索引 ------------切片方式和数组类似
s[0:2] ----kok s[::2] ---kkabr -- 从0开始取，隔2个取一个 s[3:11:2]
s[2:] ----koamber s[3:11:2] ----ome -- 从3开始到11结尾，每隔2个取一个
s[0:16] ----kokoamber s[:] ----kokoamber -- 想截取全部，结尾和0都可以省略不写
s[0:-1] ----kokoambe
s[0:-2] ----kokoamb
s[:5] ----kokoa ----- 0可以省略不写
4.字符串函数
| 函数写法 | 作用 |
|---|---|
| 空格 .strip()，.rstrip()，.lstrip() | 去除字符串首尾的空格，\n，\t。去除首(左)空格，去除尾(右)空格 |
| 大小写 .upper()，.lower()，.capitalize()，.title() | 大写字符串，小写字符串，首个字符大写，标题展示（所有单词的首字母均大写） |
| 判断 .islower()，.isupper()，.isdigit() | 是不是全小写，是不是全大写，是不是全数字（清洗用） |
| 检查数据 .startswith(‘c’)，.endswith(‘_’) | 是不是以xx字符开头，是不是以xx结尾 |
| 位置 .find()，.index() | 找到某一字符在字符串中的位置(find返回 -1不存在，index报错不存在) 举例：‘1234564321’.find(‘456’) |
| 数量 .count(‘a’) | 查找某一字符在字符串中的数量 |
| 替换 .replace(‘a’,‘b’) | 替换字符串，前为被替换，后为替换 |
| 长度 len(‘dafd’) | 查看字符串长度 |
小节练习：电话号码识别
callphone_number_start = '13 15 18 17 19' --手机号
telephone_number_start = "010 021 022 025 0888 0555" --固定电话
'400' --广告号
while True:
num = input('输入拨入的电话号码：\n')
if num.strip() == 'exit': ------ 自定义退出
break
if not num:
print('电话号码不能为空')
continue
num = num.strip()
if not num.isdigit():
print('您输入的是一个无效的电话号码')
continue
if num[:2] in callphone_number_start and len(num) == 11:
print('这是一个手机号码')
continue
if num.startswith('0'):
if (len(num) == 12 and num[:4] in telephone_number_start) or \
(len(num) == 11 and num[:3] in telephone_number_start): --- \ 是一行分成两行的固定用法
print('这是一个固定电话号')
continue --- 注意continue的缩进
if num.startswith('400') and len(num) == 10:
print('这是一个广告电话')
continue
print('您输入的是一个无效的电话号码')
5.元组( )
| 定义元组的方式 | tuple( ) |
|---|---|
| t = tuple(rang(10000)) | 打印出0-9999 |
| t = (‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’) | 打印出 (‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’) |
| t = ‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’ | 打印出 (‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’) |
| t = (‘p’,) | 打印出(‘p’,)，元组只有一个元素时需在后面加‘，’ |
1）元组和字符串类似 - - - 可使用索引 [:]，使用字符串函数，使用in
2）元组是不可变序列
t = 'p', 'y', 't', 'h', 'o', 'n'
print("+".join(t)) ----- p+y+t+h+o+n
for i in t:
print(i)
元组练习：销售统计冠军
sales = (
('peter',(78,72,60)),
('tom',(65,56,59,80)),
('tony',(62,78,79,99)),
('john',(65,54,58,50)),
)
champion = ''
max_total = 0
for name,quarter_amount in sales: ---- 一次性拿出sales元组里面的元素
total_amount = sum(quarter_amount) ---- sum函数计算
if total_amount > max_total:
champion,max_total = name,total_amount ---- 同时取出champion,max_total两个元素
print('第一季度的销售冠军是{0}，总销售额是{1}万元'.format(champion, max_total))
------第一季度的销售冠军是tony，总销售额是318万元
6.列表[ ]
| 定义列表的方式 | list( ) 变量名不要用list |
|---|---|
| lst = list(‘abcd’) | 打印出[‘a’, ‘b’, ‘c’, ‘d’] |
| lst = [1,2,3,4] | 打印出 [1,2,3,4] |
| lst = [‘sdff’,1,2,(1,3,‘na’)] | 打印出[‘sdff’, 1, 2, (1, 3, ‘na’)] |
| lst = list((1,2,3,‘tuple’)) | 打印出[1, 2, 3, ‘tuple’] |
1）列表和字符串类似 - - - 可使用索引 [:]，使用字符串函数，使用in
2）列表里数据可变 ，经常使用del
| 函数写法 | 作用 |
|---|---|
| 位置 .index() | 找到某一元素在列表中的位置, 举例：[‘afd’,456,45,32].index(‘456’) |
| 数量 .count(‘a’) | 查找某一元素在列表中的数量 |
| 插入 .insert(索引,元素) | 插入元素，前为插入位置的索引，后为插入内容 |
| 添加 .extend()，拓展 .append() | .extend(‘a’)末尾插入一个元素，.append(‘a’,‘c’,‘w’)末尾插入多个元素 |
| 删除 del | 删除元素，del b[0] - - 删除b列表的第一个元素 |
| 删除 .pop() | 删除元素，b.pop(1) - - 删除b列表的第二个元素 |
| 删除 .remove() | 可以不借助索引，直接删除元素（仅删除第一个相同元素） b.remove(‘afd’) - - 删除b列表的‘afd’元素 |
| 排序 .sort() - - 按ASCII编码值排序 | .sort()从小到大排序，.sort(reverse=True)从大到小排序 （在原有列表的基础上排序，不生成新的列表） |
| 复制 .copy() | lst2 = lst1.copy() 复制生成新的列表 |
| 翻转 .reverse() | 颠倒列表里所有元素的顺序 |
| 清除 .clear() | 清除列表内容，列表变为空（很少用，ptyhon会自动回收已使用列表） |
b = []
while b: ---- 空列表布尔值为False
print(b.pop())
sort()
按ASCII编码排序，0-9，A-Z，a-z，每个字符对应一个数字
| sort写法 | 含义 |
|---|---|
| 排序 .sort(reverse=True) | 从大到小排序，sort()默认从小到大排序 |
| 指定元素排序 .sort(reverse=True,key=lambda x:x[1]) | key=lambda x是一个函数，此为指定每个元组的第二项排序 |
lst = ['orange','apple','banana','blueberry']
lst.sort() --- 比较所有元素的首字母，若首字母相同再比较第二位字母
---- ['apple', 'banana', 'blueberry', 'orange']
revenue = [('7月',56180000),('2月',35443123),('5月',1315645321)]
revenue.sort(reverse=True) --- 按照第一个元素的ASCII值排序
---- [('7月', 56180000), ('5月', 1315645321), ('2月', 35443123)]
列表表达式
生成列表时，直接在[ ]中写表达式，简洁代码
- 生成一个列表，包含20以内的偶数
lst1 = [i for i in range(0,20) if i % 2 == 0] ------ 遍历20以内的偶数放入列表中
lst3 = [i for i in range(0,20,2)] ------ for前必须写上 i 代表把遍历出的元素放入列表
- 生成一个列表，打印26个大写字母
a_z = [chr(i) for i in range(65,65+26)] --- chr()用于将整数转换为其对应的ASCII字符
---- ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
列表练习：销售数据排行榜
1.for循环写法
sales = (
('peter',(78,72,60)),
('tom',(65,56,59,80)),
('tony',(62,78,79,99)),
('john',(65,54,58,50)),
)
total_sales = []
for name,quarter_amount in sales:
total_amount = sum(quarter_amount)
total_sales.append((name,total_amount))
--- .append()每次只能推入一个元素，加个( )把name，total_amount封装成一个元组
total_sales.sort(reverse=True,key=lambda x:x[1]) --- 按第二个元素的大小排序
print(total_sales)
--- [('tony', 318), ('tom', 260), ('john', 227), ('peter', 210)]
2.列表表达式写法
total_sales = [(name,sum(quarter_amount)) for name,quarter_amount in sales]
--- 加个( )把name，sum(quarter_amount)封装成一个元组
total_sales.sort(reverse=True,key=lambda x:x[1])
--- [('tony', 318), ('tom', 260), ('john', 227), ('peter', 210)]
7.字典{key:value,key1:value1}
- 定义字典的两种方式------ dict( ) , { } （字典内元素顺序有可能变化）
- ---------- 字典可直接搜索元素，修改元素，增加元素，删除元素
方式一：
sales = {
'tony':318,
'tom':260,
'john':227,
'peter':210,
}
方式二：
s = [('tony', 318), ('tom', 260), ('john', 227), ('peter', 210)]
sales1 = dict(s)
------ {'tony': 318, 'tom': 260, 'john': 227, 'peter': 210}
sales = {
'john':227,
'peter':210,
}
sales['mike'] = 300 ---- 增{'john': 227, 'peter': 210, 'mike': 300}
del sales['john'] ---- 删{'peter': 210}
sales['peter'] = 0 ---- 改{'john': 227, 'peter': 0}
print(sales['peter']) ---- 查210
字典的遍历和函数 .items()
for key,value in sales.items(): ---- sales.items()把元素转化成元组，for循环把两个值取出来
print(key,value)
----
tony 318
tom 260
john 227
peter 210
- 字典的函数
| 字典的函数 | 函数的含义 |
|---|---|
| .get(‘mike’,0) | 查找列表中是否有‘mike’元素，如果有返回‘mike’的值，没有返回我们设置的0； 0不设置时返回‘None’；若不使用get()函数,运行会报错 |
| .keys() | 返回字典里所有key，- - - dict_keys([‘tony’, ‘tom’, ‘john’, ‘peter’]) |
| .values() | 返回字典里所有value，- - - dict_values([318, 260, 227, 210]) |
8.集合{元素1，元素2}
集合里的元素是唯一且无序的，不能使用索引，常用于统计
.set( ) 集合和字符串类似 - - - 可使用函数，使用in
lst = ['a',1,2,3,3,4,4,5,'c']
print(set(lst))
---- {1, 2, 3, 4, 5, 'c', 'a'}
| 函数写法 | 作用 |
|---|---|
| 添加 .add() | 添加元素，添加前会比对集合内是否有相同元素，有的话不会添加 |
| 删除 .pop() | 删除元素，并返回被删除的元素 |
| 删除 .remove() | 删除元素(如果集合内没有该元素，会报错) b.remove(‘afd’) - - 删除b集合的‘afd’元素 |
| 删除 .discard() | 删除元素(如果集合内没有该元素，不会报错) b.discard(‘afd’) - - 删除b集合的‘afd’元素 |
| 求交集 .intersection() | 集合1.intersection(集合2)，求集合1和集合2的交集 |
| 求并集 .union() | 集合1.union(集合2)，求集合1和集合2的并集 |
| 判断是否是子集 .issubset() | 集合1.issubset(集合2)，判断集合1是否是集合2的子集 |
| 判断是否是父集 .issuperset() | 集合1.issuperset(集合2)，判断集合1是否是集合2的父集 |
9.自定义函数 def
自定义书写方式
方式一：
def hello2(name,sex):
print('{n}性别是{w}'.format(n=name,w=sex))
hello2('小杨','女')
方式二：
def hello2(name,sex='女'):
print('{n}性别是{w}'.format(n=name,w=sex))
hello2(name='小明')
方式三:
def hello2(name='小明',sex='女'):
print('{n}性别是{w}'.format(n=name,w=sex))
hello2()
1）return 返回值
def multiply(num1, num2):
return num1 * num2
print(multiply(2, 3))
return一般写在最末尾，有多个返回值情况不同，没写return时，函数返回None。
def permit(age):
if age >= 18:
return True ----- True
else:
return False
print(permit(18))
return可返回多个值，以元组形式返回
def find_min_max(nums):
nums.sort()
return nums[0], nums[-1] ---- 取最小值和最大值
print(find_min_max([1,2,3,6,5,9,2]))
----- (1, 9)
min,max = find_min_max([1,2,3,6,5,9,2]) ---- 拆开元组
print(min,max)
------ 1 9
2）匿名函数 lambda
无需定义函数，只需写一行简单的、单行的匿名函数，常用于map()、filter()、reduce() 等函数中
revenue = [('7月',56180000),('2月',35443123),('5月',1315645321)]
key = lambda x: x[1] ---- key生成的是一个函数
for i in revenue:
print(key(i))
plus = lambda x,y,z : x*(y+z) ---- lamdba可以多参数
print(plus(10,20,30))
revenue = [('7月',(1231,56,561)),('2月',(12312,1564,3544)),('5月',(2,4,1315))]
revenue.sort(key=lambda x:sum(x[1])) ----- lambda内部使用函数
print(revenue)
四、python进阶
1.面向对象、类、实例
类 class ： 类是某一类事物的抽象集合，用于创建对象的模版，类是一个有属性和方法的集合
对象 object ：对象是类的实例，每个对象都共有定义了它们的类的属性和方法
实例 ： 类的具体对象，创建一个类的实例
class Dog: ------ 首字母大写，驼峰命名法
pass
dog,dog1,dog2= Dog(),Dog(),Dog() ---- 定义对象
print(type(dog)) ---- <class '__main__.Dog'>，类是class Dog:
print(type(dog) == Dog) --- True ---- type用于查看任何对象的类型
print(isinstance(dog,Dog) ) ----- True isinstance(对象，类)查看某对象是否是某类
print(isinstance(1,int)) --- True
print(isinstance([],list)) --- True
2.对象的属性和方法
- _ init _(self)
初始化对象属性的特殊函数(构造函数)，类里的一个特殊方法，类实例化时会自动调用 - 2.有 self 的是普通函数，没有的是类的方法，self 代表类的实例
class Dog:
def __init__(self,creed,color='黑白色',size): ----- 对象的属性,self无需传递参数
------- 可设置默认参数，不传参时默认
self.creed = creed ------ 传参进来
self.color = color
self.size = size
def eat(self): ----- 对象的函数
print("eating...骨头")
def run(self): ----- 对象的函数
print("runing...的快")
def bark(self): ----- 对象的函数
print("barking...大声")
print(self.size) -----类内打印用self，打印自己
dog = Dog('哈士奇','黑白色','大型') ----- 对象的属性调用方法，self无需传递参数
dog.eat() ----- 对象的函数调用方法
dog.run()
dog.bark()
dog.creed = '金毛' ----- 修改对象的属性调用方法
print(dog.creed)
--------
eating...骨头
runing...的快
barking...大声
大型
金毛
3.类的属性和方法
- 1.对象之间是并行的，互不影响 ，对象可以调用类和对象的属性，类只能调用类的属性
- 2.装饰器写法 @classmethod
class Goods:
id_count = 0
----- 装饰器写法，定义类方法
@classmethod
def generate_id(cls): ----- 表示类自身的属性 cls 代表class 和写Goods一样
cls.id_count += 1
return cls.id_count ----- 类的装饰器函数须有返回值,才能被其他函数调用到
def __init__(self,name,price,discount): ----- 对象自身的属性
self.id = str(self.generate_id()).zfill(5) ----- 商品的唯一序号，00001，02789
----- 使用str.zfill(长度)将id变为5个字符长度的字符串
self.name = name
self.price = price
self.discount = discount
for _ in range(100): ----- _ 是 参数的占位符，用于没有参数使用时
g = Goods(1,2,3)
print(g.id, Goods.id_count) ----- 类只能调用自身方法，对象可以调用类和自身的方法
案例练习：电商购物车
# 商品：名称、价格、折扣率
# 购物车：商品、商品数量
class Goods:
id_count = 0
"""商品类""" ----- 相应文档
@classmethod
def generate_id(cls):
cls.id_count += 1
return cls.id_count
def __init__(self,name,price,discount=1):
self.id= str(self.generate_id()).zfill(5) ----- id转换成5位字符串
self.name = name
self.price = price
self.discount = discount ----- 折扣率
def calc_price(self):
return self.price * self.discount
class Gart:
"""购物车"""
def __init__(self):
self.cart = {} ----- 商品字典：key 商品id ，value：商品数量
self.goods_list = [] ----- 购物车里所有商品的列表,用来装g1,g2,g3
def add_cart(self,goods,num=1):
"""向购物车内添加商品"""
if goods in self.goods_list: ----- 如果商品在商品列表里，对应商品数量增加num
self.cart[goods.id] += num
else: ----- 如果商品不在商品列表里，直接添加商品名，数量设置为num
self.goods_list.append(goods)
self.cart[goods.id] = num
def remove_cart(self,goods,num=1):
"""向购物车内减少商品"""
if goods not in self.goods_list:
return ----- 如果商品不在购物车，不执行
self.cart[goods.id] -= num ----- 商品在购物车，数量减去num
if self.cart[goods.id] <= 0: ----- 如果删掉部分商品之后商品数量小于等于0，购物车删掉商品名,字典里删掉该商品
del self.cart[goods.id]
self.goods_list.remove(goods)
def get_goods_by_id(self,id):
"""根据商品id找到商品"""
for goods in cart.goods_list:
if goods.id == id:
return goods
def get_total_amount(self):
"""获取当前购物车内的总价"""
amount = 0
for id,num in self.cart.items(): ----- 字典.items()把元素转化成元组，for循环把两个值取出来
goods = self.get_goods_by_id(id) ----- 调用get_goods_by_id函数找到商品
amount += goods.price * num
return amount
def get_pay_amount(self):
"""获取实际需要支付的总价"""
amount = 0
for id,num in self.cart.items(): ----- 字典.items()把元素转化成元组，for循环把两个值取出来
goods = self.get_goods_by_id(id) ----- 调用get_goods_by_id函数找到商品
amount += goods.calc_price() * num
return amount
def show(self):
"""展示商品"""
title = ('商品id','商品名','商品价格','商品数量','此商品总价')
def show_row(row):
"""内部函数，显示购物车中的每一行"""
for col in row:
print(str(col).ljust(12), end='\t')
print()
show_row(title)
for id,num in self.cart.items():
goods = self.get_goods_by_id(id)
price = '%.2f(不打折)' % goods.price
if goods.discount < 1: ----- 如果打折展示打折率
price = '%.2f(%d折)' % (goods.price,goods.discount * 100)
show_row((id,goods.name,price,num,'%.2f' % (goods.calc_price() * num)))
show_row(('','','','','总金额：%.2f' % cart.get_total_amount()))
discount_amount = cart.get_total_amount() - cart.get_pay_amount()
if discount_amount > 0: ----- 如果折扣金额大于0，展示优惠价格
show_row(('', '', '', '', '优惠了：%.2f' % discount_amount))
show_row(('','','','','实付金额：%.2f' % cart.get_pay_amount()))
g1 = Goods("苹果手机",6800,0.98)
g2 = Goods("小米手机",4500,0.99)
g3 = Goods("华为手机",12700)
cart = Gart()
cart.add_cart(g1,2)
cart.add_cart(g2,7)
cart.add_cart(g3,3)
cart.remove_cart(g2,2)
cart.show()
4.内置模块导入import
导入一个模块
方法一：import math ----- 导入math模块
方法二：from math import sqrt ----- 具体导入math里的sqrt(算数平方根)模块
方法三：from math import sqrt as sq ----- 具体导入math里的sqrt(算数平方根)模块,取名为sq
导入多个模块
方法一：import sys,os ----- 导入两个模块
方法二：from math import sqrt,pow ----- 具体导入math里的两个模块
1）日期时间模块
datetime，timedelta，time
from datetime import datetime,timedelta
import time
| datetime | from datetime import datetime |
|---|---|
| datetime.now() | 返回当前系统时间：2025-05-29 14:57:58.961962 |
| now.timestamp() | 时间戳 1978-1-1 00:00:00 截止到目前的时间(秒) 一般用于比较时间 |
| now.strftime(“%Y-%m-%d %H:%M:%S”) | 格式化时间固定写法： 2025-05-29 15:30:46 |
| now.year,now.month,now.day | 年月日 |
| now.replace(year=2020,month=now.month,day=1) | 替换时间：2020-05-01 15:35:21 |
| timedelta | from datetime import timedelta |
|---|---|
| now + timedelta(days=20,hours=20) | + - 时间可做加减法 |
| time | import time |
|---|---|
| time.time() | 时间戳 1978-1-1 00:00:00 截止到目前的时间(秒) 一般用于比较时间 |
| time.strftime(“%Y-%m-%d %H:%M:%S”) | 格式化时间固定写法： 2025-05-29 15:30:46 |
| time.sleep(seconds) | 程序到这里暂停xx秒：time.sleep(6) 暂停6秒 |
2）生成随机数
random
| random | import random |
|---|---|
| random.random() | 随机生成0-1之间的数,包含0不包含1 |
| random.randint(1,10) | 随机生成1-10之间的整数，包含1,10 |
| random.choice(az) | 随机抽取az里的一个数(非空) |
| random.choices(az, k=6) | 随机抽取az里的6个数(非空)，可换成random.sample(az, k=6)，抽取的数不重复 |
| random.shuffle( list ) | 随机打乱顺序（只能是列表） |
3）os模块（操作系统接口）
| os | import os |
|---|---|
| os.getcwd() | 获取当前程序运行的目录 |
| os.mkdir(os.getcwd()+‘/test’) | 在当前工作目录下创建目录（一层） |
| os.makedirs(os.getcwd()+‘/abc/132’) | 在当前工作目录下创建目录（多层） |
| os.listdir(os.getcwd()) | 列出指定目录下的所有文件，‘ / ’ 根目录 |
| os.path.abspath(‘./’) os.path .abspath ( _ _ file _ _) | 当前代码文件所在绝对路径，绝对路径 C:\document\ 相对路径 ./ …/ . 表示当前目录， . . 表示父级目录 Windows: \ Mac和Linux / |
| os.path.isfile( _ _ file _ _ ) | 判断“文件”是否存在 |
| os.path.join(os.getcwd(),‘abc’,‘132’) | 拼接目录:C:\Users\Shop\abc\132 |
| os.path.dirname(运行文件路径) | 截取该运行文件的目录：C:\Users\Shop\abc |
| os.path.basename(运行文件路径) | 截取该运行文件的文件名：132.py |
4）sys模块（查询系统相关参数和函数）
| sys | import sys |
|---|---|
| sys.path | 以列表形式返回各种python包存放目录 |
| sys.path.append( ‘./test’ ) | 把./test下的文件放到sys.path中 |
| sys.argv | 保存用户输入到命令行里的参数 |
if __name__ == '__main__':
print("hello world",end="")
if len(sys.argv)>1:
print(''.join(sys.argv[1:]))
5.自定义模块导入
- 同级目录下的导入
from goods import Goods ----- 同级目录下可直接导入模块
from cart import Gart ----- 最小化导入，需要什么取什么
from goods import Goods,AAA,show_row ----- 可导入类，函数，变量
from goods import * -----全部导入
- 非同级目录下的导入
from Shopcart.cart import Gart ----- 非同级目录需写出嵌套结构（一层嵌套）
from Shopcart.Cart.goods import Goods
创建python软件包
- 主入口文件（固定写法：if _ name _ == ‘_ main _’: ）
写在main文件中
if __name__ == '__main__': ----- 只有文件名等于__main__的文件才会运行(主入口文件)，其他都是模块
g1 = Goods("苹果手机",6800,0.98)
g2 = Goods("小米手机",4500,0.99)
扫一扫
1586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
