Python入门学习
文章目录
一、Python初探
1.Python注释
"""
这是python的多行注释
"""
print("Hello") # 这是Python的单行注释
x = 1
y = 2
z = 3
x, y, z = z, y, x # 交换x, y, z的值
2.Python字符串
# 字符串可以用''、""、""" """
print("hello") # hello
print('he side : "Hello"') # he side : "Hello"
print('''he 'side' : "Hello"''') # he 'side' : "Hello"
# 使用\符号可以在编辑器里起到换行书写的作用
print("这个字符串\
好长啊\
!!!")
# 三双引号字符可以包含换行符、制表符以及其他特殊字符
para_str = """制表符Tab[\t] 换行符[\n]"""
print(para_str)
# 字符串的下标
# 有n个字符的字符串，其中的每个字符都是长度为1的字符串
# 从左到右依次编号0,1,2...n-1
# 从右到左依次编号-1,-2...-n
str_ = "abcde"
print(str_[0], str_[1], str_[-1]) # a b e
# 用+号连接字符串
a = "abc"
b = "123"
a = a + b
print(a) # abc123
# 字符串不可修改，字符串中的字符不能修改
# a = "abc"
# a[0] = 'A' 这是错误的
# 用in, not in 判断子串
str1 = "Hello"
str2 = "Python"
print("el" in str1) # True
print("th" not in str2) # False
print("lot" in str1) # False
# int(x) : 将字符串x转换成整数 (x不会变成整数，int(x)这个表达式的值是整数)
# float(x) : 将字符串x转换成小数
# str(x) : 将x转换成字符串
# eval(x) : 把字符串x看作一个python表达式，求其值
a1 = 15
b1 = "12"
# print(a1 + b2) 这是错误的，在python中，整数不能和字符串相加
print(a1 + int(b1)) # 27
print(str(a1) + b1) # 1512
print(eval("3.5")) # 3.5
print(eval("3+2")) # 5
print(eval("3+a1")) # 18
# int(x) : 若x是小数，则去尾取整
print(int(3.7)) # 3
3.Python 数据类型
1.int 整数 123
2.float 小数 3.2
3.complex 复数 1+2j
4.str 字符串 "hello"
5.list 列表 [1, 2, 'Ok', 2.4]
6.tuple 元组 (1, 2, 'OK', 2.4)
7.bool 布尔 True False
8.dict 字典 {"Tom":20, "Jack":30}
9.set 集合 {"tom", 18, 71}
4.Python 输入输出
# print(x, y, z...) 连续输出多项，以空格分隔，然后换行
print("123", 456)
# print(x, y, z..., end=" ") 连续输出多项，以空格分隔，不换行
print(1, 2, end=" ")
print("OK") # 1 2 OK
# 输入语句 input
# x = input(y)
# x是变量，y是字符串或任何值为字符串的表达式
# 输出y，并等待输入。敲回车后输入的字符串被赋值给x
# input() 每次输入一行，如果多行输入，就用多次input()
s = input("请输入您的名字:")
print(s + ",您好")
ss = int(input())
aa = int(input())
print(ss + aa)
5.初步认识列表
# 列表可以有0到任意多个元素，元素可以通过下标访问
# 列表中元素的值可以修改，元素的下标可以是变量
empty = [] # 空表
list1 = ['Google', 'Huawei', 1, 1.2]
list1[0] = 100
print("list1[0]:", list1[0])
print("list1[2]:", list1[2])
# 用in判断列表里面是否包含某个元素
lst = [1, 2, 3, "4", 5]
print(4 in lst, "4" in lst) # False True
# 输入两个数求和
s = input() # 输入3 4, s是字符串"3 4"
numbers = s.split() # numbers是一个列表['3', '4']
print(int(numbers[0]) + int(numbers[1]))
# 字符串分割为列表
# 若x是字符串，则x.split()的值是一个列表，包含字符串x经空格、制表符、换行符分隔得到的所有子串
print("34\t\t45\n7".split())
print("ab cd hello".split())
6.字符串切片
若s是一个字符串，则 s[x:y] 是s的从下标x到下标y-1构成的子串（切片）
print("12345"[1:3]) # 23
a = "abcdef"
print(a[2:-1]) # cde
print(a[0:6]) # abcdef
二、基本运算、条件分支和输出格式控制
1.算术运算符
+ 加法
- 减法，取相反数
* 乘法
/ 除法，结果是小数（即使能整除也是小数）
% 取模
// 求商，结果是整数
** 求幂
print(3.4 // 2.2) # 1.0
print(-9 // 4) # -3,往小里取整
print(2 ** 3) # 8
注意：有小数参与的算术表达式，结果一定是小数
算术运算的同时赋值
+=
-=
*=
/=
%=
//=
**=
2.比较运算和逻辑运算
1.比较运算符：== != < > <= >=
a = 4
print(2 < a < 6 < 8) # True 在Python中，可以连着写符号
print(2 < a == 4 < 6) # True
print(2 < a > 5) # False
# 在Python中，True就是1，False就是0
b = a < 6
print(b == 1) # True
print(b == 2) # False
b = a > 6
print(b == 0) # True
a = True
print(a == 1) # True
# 关系运算符也可以比较字符串（按字典序，大小写相关）
print("abc" < "acd") # True
print("abc" < "abcd") # True
print("abc" > "Abc") # True
2.逻辑运算符用于逻辑表达式的逻辑操作，有 and or not 三种，结果是True和False
什么相当于True或False
i. 0, ""(空字符串), [](空表) 都相当于False (但除0以外都不等于False)
ii.非0的数，非空的字符串和非空列表，都相当于True (但除1以外，都不等于True)
iii.True可以看作1，Flase可以看作0
True == 1 # True
False == 0 # True
"" == False # False
2 == True # False
[] == False # False
[2,3] == True # False
not 运算符的使用：not exp
not [] # True
not 4 < 5 and 4 > 6 # False (这里先算not 4 < 5,再和 4 > 6进行and运算)
not and or 的优先级: not > and > or
3.逻辑表达式是短路运算的，即对逻辑表达式的运算，在整个表达式的值已经能够断定的时候就会停止
exp1 and exp2 : 如果已经算出exp1为假，那么整个表达式为假，exp2就不需要计算了
exp1 or exp2 : 如果已经算出exp1为真，那么整个表达式为真，exp2就不需要计算了
3.条件分支语句
if 逻辑表达式1:
语句组1
elif 逻辑表达式2:
语句组2
...
else:
语句组
4.输出格式控制
字符串中的格式控制符：
%s 表示此处要输出一个字符串
%d 表示此处要输出一个整数
%f 表示此处要输出一个小数
%.nf 表示此处要输出一个小数，保留小数点后面n位，四舍六入，五可能舍可能入
注意：格式控制符只能出现在字符串中
h = 1.746
print("my name is %s, I am %.2f tall." % ("tom", h)) # my name is tom, I am 1.75 tall.
print("my age is %d" % 18) # my age is 18
print("%.2f %.2f" % (5.225, 5.325)) # 5.22 5.33
三、循环语句
1.for循环语句格式：
for variable in sequence:
statements1
else:
statements2
依次对sequence中的每个值执行，然后再执行;
通常情况下，else:是不需要的;
sequence可以是range()，也可以是字符串、列表、元组、字典、集合 range(x, y) 范围为[x,y)
range(x, y, a) 范围为[x,y) 步长为a
len()函数可以求字符串长度、元组、集合、字典元素个数
for i in range(0, 10):
print(i)
for i in range(1, 10, 3):
print(i)
for i in range(0): # 无输出
print(i)
for i in range(2,2): # 无输出
print(i)
for循环遍历列表——写法1：
a = ['Google', 'Baidu', 'IBM', 'Taobao', 'QQ']
for i in range(len(a)):
print(i, a[i])
"""
输出：
0 Google
1 Baidu
2 IBM
3 Taobao
4 QQ
"""
for循环遍历列表——写法2：
a = ['Google', 'Baidu', 'IBM', 'Taobao', 'QQ']
for i in a:
print(i)
"""
输出：
Google
Baidu
IBM
Taobao
QQ
"""
for循环遍历字符串：
for letter in 'Taobao':
print(letter)
"""
输出：
T
a
o
b
a
o
"""
2.break语句的使用：
- break的作用是跳出循环
- else子句在for循环结束时会执行，但是如果break了，则不会执行
3.continue语句的使用：
- continue的作用是直接跳到下次循环
4.字符的编码
- ord(x) 求字符x的编码（字符就是长度为1的字符串）
- chr(x) 求编码为x的字符
# 连续输出26个字母
for i in range(26):
print(chr(ord("a") + i), end="")
# 连续输出0-9
for i in range(10):
print(chr(ord('0') + i), end="")
5.while循环语句
while 逻辑表达式exp:
语句组1
else:
语句组2
6.异常处理
try:
<语句组1>
except:
<语句组2>
常见的异常：
- 不合适的转换，例如：int(“abc”)，int(“23.34”)，float(“abc”)
- 输入已经结束（已经没有输入数据了）后，还执行input()
- 除法除数为0
- 整数和字符串相加
- 列表下标越界
"""
输入若干行，每行若干个数字，求出这些数字中最大的那一个
"""
s = input()
lst = s.split()
maxV = int(lst[0])
try:
while True:
lst = s.split()
for i in lst:
maxV = max(maxV, int(i))
s = input()
except:
pass
print(maxV)
四、函数与递归
函数的定义：
def 函数名(参数1, 参数2···):
语句组(即函数体)
注意：
return语句的功能是结束函数的执行，并将“返回值”作为结果返回。“返回值”是常量、变量或复杂的表达式均可。如果函数不需要返回值，return语句就直接写return
函数可以返回多个值
函数中的变量如果与全局变量（函数外定义的变量）同名的情况（假设都叫x）
1 如果没有对x赋值，函数中的x就是全局的x
2 如果对x赋值，且没有特别声明，则在函数中全局的x不起作用，函数中的x就是只在函数内部起作用的x
3 函数内部可以使用global x声明函数中的x就是全局变量x
x = 4 # 全局的x
def f0():
print("x in f0:", x) # 这个x是全局的x
def f1():
x = 8
print("x in f1:", x) # 这个x是局部的x，不会改变全局的x
def f2():
global x # 说明本函数中的x就是全局的x
print("x in f2:", x)
x = 5
print("x in f2:", x)
def f3():
print("x in f3:", x) # 报错。因为后面有赋值而被当作局部的x，此处没有赋值就先使用了
x = 9
"""
递归例题：
上台阶：有n级台阶，每步可以走一级或两级，有多少中走法
"""
def f(x):
if x == 1:
return 1
elif x == 2:
return 2
else:
# 第一步走一级的走法 + 第一步走两级的走法
return f(x-1) + f(x-2)
"""
汉诺塔问题
"""
def hanoi(n, src, mid, dest):
if n == 1:
print(src + "->" + dest)
return
else:
hanoi(n-1, src, dest, mid)
print(src + "->" + dest)
hanoi(n-1, mid, src, dest)
hanoi(3,'A','B','C')
五、元组
# 例1：创建元组
# 元组（只读列表）里面的值不可变
tuplename = (1, 2, 3, 4, 5, 6)
coffe = ('蓝山', '摩卡', '卡布奇诺')
grade = ('name', 'number', 2008, 2017)
# 如果创建的元祖里面只有一个元素，一定要加‘，’，不然编译器会把它当成一个基本类型元素
tup = (100,)
print(type(tup)) # <class 'tuple'>
tup1 = (100) # <class 'int'>
print(type(tup1))
print(tuplename)
print(coffe)
print(grade)
# 例2：创建数值元组
# tuple是元祖的保留字
array = tuple(range(2, 21, 2)) # 将序列转换成元组
print(array)
# 例3:两列输出球队名称
print("我知道的NBA球队名称：")
team = ("火箭", "勇士", "开拓者", "公牛", "森林狼", "湖人", "爵士", "马刺")
# 索引访问元祖
for i in range(0, 8):
print(team[i], end=' ')
if (i == 7): print()
# 切片方式显示
print(team[0:4])
print(team[4:8])
# 直接打印元祖
print(team)
# 例4：修改元组
# 元祖不能修改某一个元素，只能修改元祖本身
tup1 = (1, 2, 3, 4, 5)
tup1 = (1, 2, 3, 4, 5, 6, 7, 8)
# 元祖可以在原来的基础上衔接
tup2 = ('a', 'b', 'c', 'd', 'e')
tup3 = tup1 + tup2
print(tup3)
# 例5：快速生成元组、删除元组
import random
# 生成随机序列对象
randomtuple = (random.randint(10, 100) for i in range(10))
print(tuple(randomtuple)) # 用tuple转换
print(randomtuple)
print(tuple(randomtuple))
numb = tuple(random.randint(10, 100) for i in range(5))
for i in numb:
print(i, end=' ')
print(numb)
# 删除元祖
del numb # 不能删除元祖的某一个元素，只能删除整个元祖
print(numb)
六、列表
# 例6：列表操作(赋值、添加、修改、删除)
tuplename = [7, 2, 8, 4, 5, 1]
coffe = ['蓝山', '摩卡', '卡布奇诺']
grade = ['name', 'number', 2008, 2017]
name = ['zhao', 'Qian', 'sun', 'Li', ]
# 创建空列表
emptylist1 = []
emptylist2 = [None]
# 使用for循环遍历列表
for i in tuplename:
print(i)
# enumerate可以提取出下标和元素
for index, item in enumerate(tuplename):
print(index, item)
tuplename[1] = 1000 # 修改列表元素
tuplename.append(666) # append函数在列表末尾添加元素
list1 = [1, 2, 3]
tuplename.extend(list1) # entend函数把新的列表添加到列表后
print(tuplename)
tuplename.insert(1, "hello") # insert函数
print(tuplename)
# remove方法移除表中的某个元素第一个匹配的项,参数是元素
tuplename.remove("hello")
# pop方法可以移除列表中的某个元素，参数是下标（默认删除最后一个元素）
tuplename.pop(0);
# del函数
del tuplename[1] # 删除指定索引的元素
# index方法找出第一个匹配项的索引，参数是元素
x = tuplename.index(4)
# count方法可以统计某个元素在列表中出现的次数，参数是元素
print(tuplename.count(4))
# sum方法可以对数值型列表求和
print(sum(tuplename))
# max求最大值
print(max(tuplename))
# reverse方法反向放置
tuplename.reverse()
# sort方法排序
tuplename.sort()
# 对列表name排序
name.sort(key=str.lower, reverse=True)
# 例7：排序与计算
name = ['chen', 'Qian', 'sun', 'Li']
song = ['天上飞', '空空如也', '刚好遇见你', '天上飞', '黄河谣']
listname = [7, 2, 8, 4, 5, 1]
# 用对象的排序方法，排序后原列表改变
name.sort()
print(name) # ['Li', 'Qian', 'chen', 'sun']
name.sort(key=str.lower, reverse=True)
print(name) # ['sun', 'Qian', 'Li', 'chen']
# 使用内置函数排序，排序后原列表不会改变
la = sorted(listname, reverse=True) # [8, 7, 5, 4, 2, 1]
print(la)
print(listname) # [7, 2, 8, 4, 5, 1]
# 例8：列表推导式
price = [100, 500, 288, 800, 888, 1000]
newprice = [i / 2 for i in price]
print(newprice)
print("800以上的价格折扣为")
x = float(input())
partprice = [item * x for item in price if item >= 800]
print(partprice)
七、字符串
# 格式化字符串
# 使用 % 操作符
print('My name is %s' % ('Tom'))
template = '编号：%09d\t公司名称：%s \t官网：http://www.%s.com' # 定义模板
context1 = (7, '百度', 'baidu')
context2 = (8, '新浪', 'sina')
print(template % context1)
print(template % context2)
template1 = '编号：{:0>9d}\t公司名称：{:s} \t官网：http://www.{:s}.com' # 定义模板
context3 = template1.format(7, '百度', 'baidu')
context4 = template1.format(8, '新浪', 'sina')
print(context3)
print(context4)
# 检索字符串
list1 = 'yiyi @linyu @jixuan @chenli'
# count() 返回指定字符串出现的次数
print(list1.count(' @')) # 3
# find() 返回指定字符串的索引号，如果没找到返回 -1
print(list1.find(' @')) # 4
print(list1.find(' @')) # 4
print(list1.find('scasc')) # -1
# index() 返回指定字符串的索引号，如果没找到就会抛出异常
print(list1.index(' @')) # 4
#print(list1.index('asca')) # 抛出异常
print(list1.startswith('&'))
print(list1.startswith('yiyi'))
print(list1.endswith('li'))
print(list1.endswith('&'))
print(list1.startswith('@', 5)) # 判断从索引3开始是不是以@开始
print(list1.startswith('@', 5, 8)) # 判断从索引5开始,8结束是不是以@开始
# join() 连接字符串
list2 = ['Tom', 'Jack', 'Sam', 'Peter']
str1 = "@".join(list2)
print(str1) # Tom@Jack@Sam@Peter
# split() 分割字符串
str2 = "hello world i am coming"
str3 = "hello*world*i*am*coming"
list2 = str2.split()
list3 = str3.split('*')
list4 = str3.split('*', 2) # 指定最多分割2次
print(list2) # ['hello', 'world', 'i', 'am', 'coming']
print(list3) # ['hello', 'world', 'i', 'am', 'coming']
print(list4) # ['hello', 'world', 'i*am*coming']
# strip([chars])
# lstrip 去除左边的特殊字符
# rstrip 去除右边的特殊字符
str1 = "heeh"
str2 = str1.strip("h") # ee
str3 = str1.lstrip("h") # eeh
str4 = str1.rstrip("h") # hee
# lower() 和 upper()
str1 = "hello"
str2 = "HELLO"
print(str1.upper())
print(str2.lower())
八、字典
1. 字典的键必须是唯一的，不能是列表，值可以是重复的 2. dict是字典的关键字
1.创建字典
ch = {} # 空字典
ch1 = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(ch)
print(ch1)
# 使用两个列表用zip()转换为字典
name = [1, 2, 3, 4]
sign = ['1', '2', '3', '4']
zip1 = zip(name, sign) # zip1不是字典
newdict = dict(zip1) # 转换成字典
print(zip1)
print(newdict)
print(len(newdict))
name1 = (1, 2, 3, 4) # 元祖可以作为键
sign1 = ['1', '2', '3', '4']
newdict1 = {name1: sign1}
print(newdict1) # {(1, 2, 3, 4): ['1', '2', '3', '4']}
print(len(newdict1)) # 1
newdict2 = dict([(1,3),(2,4),(3,5)]) # 将元祖构成的列表转化为字典
2.删除字典
del 字典名 是删除字典
字典名.clear() 是清空字典中的所有项，使字典变为空字典
3.字典的添加和修改
ch1 = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(ch1.get('key1')) # value1
print(ch1.get('key4')) # None
print(ch1['key2']) # value2
print(ch1['key3'] if 'key3' in ch1 else '查无此数据') #
print(ch1.get('key4', '查无此数据')) # 如果查不到就用指定值
list1 = list(ch1.items())
list2 = list(ch1.keys())
list3 = list(ch1.values())
print(list1)
print(list2)
print(list3)
# 字典的增加和删除
ch = {'a':1,'b':2,'c':3,'d':4,'e':5}
ch['f'] = 6
print(ch)
ch['a'] = 100
print(ch)
# 使用update方法
d = {'a':1, 'b':2, 'c':3}
x = {'d':4, 'a':100}
d.update(x)
print(d)
# 字典间的互动访问
name = ['王梦','伊一','李香','赵兰'] # 作为键的列表
sign_person = ['水瓶座','射手座','双鱼座','双子座'] # 作为值的列表
person_dict = dict(zip(name,sign_person)) # 转换为个人字典
sign_all =['白羊座','金牛座','双子座','巨蟹座','狮子座','处女座','天秤座','天蝎座','射手座','摩羯座','水瓶座','双鱼座']
nature = ['有一种让人看见就觉得开心的感觉，阳光、乐观、坚强，性格直来直往，就是有点小脾气。',
'很保守，喜欢稳定，一旦有什么变动就会觉得心里不踏实，性格比较慢热，是个理财高手。',
'喜欢追求新鲜感，有点小聪明，耐心不够，因你的可爱性格会让很多人喜欢和你做朋友。',
'情绪容易敏感，缺乏安全感，做事情有坚持到底的毅力，为人重情重义，对朋友和家人特别忠实。',
'有着宏伟的理想，总想靠自己的努力成为人上人，向往高高在上的优越感，也期待被仰慕被崇拜的感觉。',
'坚持追求自己的完美主义者。',
'追求平等、和谐，擅于察言观色，交际能力很强，因此真心的朋友不少。最大的缺点就是面对选择总是犹豫不决。',
'精力旺盛，占有欲强，对于生活很有目标，不达目的誓不罢休，复仇心重。',
'崇尚自由，勇敢、果断、独立，身上有一股勇往直前的劲儿，只要想做，就能做。',
'是最有耐心的，为事最小心，也是最善良的星座。做事脚踏实地，也比较固执，不达目的不放手，而且非常勤奋。',
'人很聪明，最大的特点是创新，追求独一无二的生活，个人主义色彩很浓重的星座。',
'集所有星座的优缺点于一身。最大的优点是有一颗善良的心，愿意帮助别人。']
# 转换为星座字典
newname = input("请输入姓名：")
print("{}的星座是{}".format(newname,person_dict.get(newname))) # 输出星座
print("\n 她的性格特点是：\n\n",sign_person.get(person_dict),"人名出错") # 输出性格特点
# fromkeys()方法使用给定的键建立新的字典，每个键默认的对应值为None
print({}.fromkeys([1, 2]))
print(dict.fromkeys([1, 2], 'a')) # 指定默认值为'a'
# copy方法
a = {1: 'x', 2: 'y', 3: 'z'}
b = a.copy()
print(b)
# pop方法
a = {1: 'x', 2: 'y', 3: 'z'}
a.pop(1)
print(a)
# setdefault方法，一旦setdefault后，再次setdefault无法改变值，但可以直接修改
a = {}
a.setdefault(1, 'a')
a[1] = 'b'
print(a)
八、面向对象
1.基本定义
class Person:
'''这是一个类'''
count = 0
def __init__(self, name, age=20, sex='M'):
self.name = name
self.age = age
self.sex = sex
self.count = Person.count + 1
Person.count += 1
def printInfo(self):
print(self.name, self.age, self.sex, self.count)
perList = []
perList.append(Person("__HDL__", 220, 'MAN'))
perList.append(Person("LXY"))
perList.append(Person("www"))
for i in perList:
i.printInfo()
2.访问控制
_foo 是protected的，类本身和子类可以访问
__foo 是private的，类本身可以访问，对象不能直接访问
__foo__ 是系统的
可以通过"对象名._类名__foo"在类外直接访问私有属性
3.继承
class Person:
def __init__(self, ...):
class Teacher(Person): # Teacher类继承Person类
def __init__(self, ...):
Person.__init__(...)
4.程序中的错误
Python语言包含的3中错误：
1. 语法错误：python解释器会帮助我们在运行程序之前识别
2. 语义错误：采用了错误的算法导致的
3. 运行错误：由没有考虑到的特殊情况导致的
ZeroDivisionError:除数为0的错误
NameError：访问没有声明的变量
IndexError：索引越界
KeyError：请求一个不存在的字典关键字
TypeError：类型不合适
MemoryError：内存不足
ValueError：传入的值错误
IndentationError：缩进错误
ImportError：无法找到模块或无法在模块中找到相应的名称
ArributeError：尝试访问位置的对象属性引发的错误
IOError：输入/输出错误（如果读取的文件不存在）
抛出异常
try:
...
except [ExceptionName [as alias]]:
...
except [ExceptionName [as alias]]:
...
else:
...
finally:
...
32万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
