零基础学python（持续更新中。。。）

零基础学python

打印

#sep是几个字符中间依靠什么连接，默认空字符
print('hello jwq','zhn','zzz',sep='|')
#end是结尾什么连接，默认\n，换行
print('hello',end=',')

数值类型

#int 整型 type() 里面是判断类型
num=1
print(type(num))
#打印内容<class 'int'>

#float 浮点型
num=0.5
print(type(num))
#打印内容<class 'float'>

#bool 布尔类型 False True 大小写固定写法 这两个也可以当做整型False=0  True=1
num=True
print(type(num))
#打印内容<class 'bool'>

#complex 复数型 其中的2为实部，3为虚部，j为虚数单位，这个也只能是j
num=2+3j
print(type(num))
#打印内容<class 'complex'>
num1=2+3j
num2=3+2j
print(num1+num2)
#打印内容(5+5j)

#str 字符串类型
num='123'
print(type(num))
#打印内容<class 'str'>

格式化输出

#%s格式化输出 占位符 注意% name 中间空一格，不空也能输出，最好空一下
name='jwq'
print('我的名字：%s' % name)

#%d 整数输出 其中的4位数字位数，刚好为顶格，有多前面会加空格（前面设置了0（如04）除外，会用0补齐），少了还是正常显示
name='jwq'
age=12
print('我的名字：%s,我的年龄：%04d' % (name,age))

#%f 浮点数 默认后面补6位，遵循四舍五入 .2一定要加点，不加就是整数（会变成默认6位），加了位数就不遵循四舍五入了，直接舍去
age=1.2337
print('%.2f' % age)

#%% 后面加()就行了
print('我是%%的%%' % ())
#输出 我是%的%

#f格式化 类似于模板语法
name='jwq'
age=18
print(f'我的名字：{name}，我的年龄：{age}')
#输出 我的名字：jwq，我的年龄：18

算数运算符

#加法
print(1+1)
#输出 2

#减法
print(1-1)
#输出 0

#乘法
print(1*1)
#输出 1

#除法 商一定是浮点型，且除数不能为0，向下取整，只要未被除尽一直除，不四舍五入
print(1/3)
#输出 0.3333333333333333

#取余 除法取余数
print(4%3)
#输出 1

#幂 相当于2的3次方
print(2**3)
#输出 8 

#取整除 若有浮点数，也会用浮点数
print(3//2)
#输出 1
#如下
print(5.6//2)
print(5//2.0)
#都输出 2.0

#优先级顺序 可以用()调整优先级
幂>乘除取余取整除>加减

#+= 赋值运算符 等同于a1=a1+1
a1=1
a1+=a1
print(a1)
#输出 2

#+= 赋值运算符 等同于a1=a1-1
a1=1
a1-=a1
print(a1)
#输出 0

输入函数

name=input("请输入你的名字：")
print(name)
#输出 请输入你的名字：123
#输出 123

转义符

#制表符 \t 通常占用四个字符
print('姓名\t年龄\t电话')
#输出 姓名	年龄	电话

#换行符 \n 
print('姓名\n年龄\n电话')
#输出 姓名		
#输出 年龄
#输出 电话

#回车符 \r 将当前位置移到最开头
print('姓名\r年龄\r电话')
#输出 电话

#反斜杠 \\ 
print('姓名\\年龄\\电话')
#输出 姓名\年龄\电话

#r 就是里面不转义，取消转义
print(r'姓名\\年龄\\电话')
#输出 姓名\\年龄\\电话

if判断

age=19
if age<18:
    print("你还没有成年哦！")
else:
    print('你成年了')
#输出 你成年了

#在写一个成绩判断
score=input('请输入你的成绩：')
if score<'60':
    print("成绩不合格！")
else:
    print(f'成绩合格了，成绩为{score}')
#输入 请输入你的成绩：99
#输出 请输入你的成绩：99

比较运算符

# ==
print(100 == 100)
#输出 True

# !=
print(100 != 100)
#输出 False

# > <
print(100 > 90)
print(100 < 90)
#输出 True
#输出 False

逻辑运算符

# and 两边都为真才是真，一边为假就是假
print(100>90 and 90>80)
#输出 True

# or 一边为真就是真
print(100>90 or 90<80)
#输出 True

# not 表示相反结果 本来为假，加入了not就为真
print(not 100<90)
#输出 True

三目运算（三元表达式）

age=19
print("你还没有成年哦！") if age<18 else print('你成年了')
#输出 你成年了

#elif 第n个判断条件
age=19
if age<18:
    print("你还没有成年哦！")
elif 18<age<23:
    print('你在读大学哦')
elif age>23 :
    print('你已经长大了')
#输出 你在读大学哦

# if嵌套
score=input('请输入你的成绩：')
if score<'60':
    print('成绩不合格')
else :
    if '60'<score<'80':
        print('成绩及格')
    elif '80'<score<'90':
        print('成绩良好')
    else:
        print('成绩优秀')
#输入 请输入你的成绩：91
#输出 成绩优秀

循环

# while循环 如果while循环条件一直为true，那么就是死循环，比如这里不加i+=1
i=1
while i<5:
    print('继续努力！')
    i+=1
#输出 继续努力！
#输出 继续努力！
#输出 继续努力！
#输出 继续努力！

# while循环嵌套
i=1
while i<3:
    print('继续努力！')
    i+=1
    j=1
    while j<3:
        print('天天向上！')
        j+=1
#输出 继续努力！
#输出 天天向上！
#输出 天天向上！
#输出 继续努力！
#输出 天天向上！
#输出 天天向上！

# for循环（迭代循环）
str='abcd'
for i in str :
    print(i)
#输出 a
#输出 b
#输出 c
#输出 d

# range循环计数器 第一个参数是开始，第二个参数是结束，第三个是步长，遵循左闭右开
for i in range(0,3) :
    print(i)
#输出 0
#输出 1
#输出 2

#做一个1+2+3+...+100的结果
num=0
for i in range(1,101) :
    num+=i
print(f'最终的计算结果：{num}')
#输出 最终的计算结果：5050

# break 直接退出循环
num=0
for i in range(1,5) :
    num+=i
    print(i)
    if num==3:
        print('我等于3了，该直接退出了')
        break
#输出 1
#输出 2
#输出 我等于3了，该直接退出了

# continue
num=0
for i in range(1,5) :
    num+=i
    print(i)
    if num==3:
        print('我等于3了，该退出当前循环了')
        continue
#输出 1
#输出 2
#输出 我等于3了，该退出当前循环了
#输出 3
#输出 4

编码

# Unicode
name='jwq'
name1=name.encode()
name2=name1.decode()
print(name1)
print(name2)
#输出 b'jwq'
#输出 jwq

#uft-8
name='蒋先生'
name1=name.encode('utf-8')
name2=name1.decode('utf-8')
print(name1)
print(name2)
#输出 b'\xe8\x92\x8b\xe5\x85\x88\xe7\x94\x9f'
#输出 蒋先生

字符串运算符

# +
name='蒋先生'
name1='太帅了'
print(name+name1)

# *
name='蒋先生'
name1='太帅了\n'
print((name+name1)*2)
#输出 蒋先生太帅了
#输出 蒋先生太帅了

# in not in
name='jwq'
print('j' in name)
print('j' not in name)
#输出 True
#输出 False

#[] 下标开始从0开始，从右往左 -1开始
name='jwq'
print(name[0])
print(name[-1])
#输出 j
#输出 q
#切片
name='jwq'
print(name[0:2])
print(name[0:-1])
print(name[1:])
print(name[:1])
print(name[:])
print(name[0::2]) #步长为2去切
print(name[0:2:2])#0-2步长为2去切
#输出 jw
#输出 jw
#输出 #输出 wq
#输出 j
#输出 jwq
#输出 jq
#输出 j

字符串常见操作

# find，index 寻找字符串，如果存在就返回字符串所在下标，find如果不在则返回-1，index直接报错
name='jwq'
print(name.find('w'))
print(name.index('w'))
#输出 1
#输出 1

# count 某个字符在字符串中出现的次数，不存在显示0
name='jwqqwj'
print(name.count('w'))
#输出 2

# startswith 某个字符串是否在这个字符串开头，如果给定一个范围就在范围中寻找
# endswith 看结尾，其他同上
name='jwqqwj'
print(name.startswith('jwq'))
print(name.endswith('wj'))
#输出 True
#输出 True

# isupper 所有字母是否为大写
name='jwqqwj'
print(name.isupper())

# replace 替换
name='jwqqwj'
print(name.replace('j','z'))
print(name.replace('j','z',1))
#输出 zwqqwz
#输出 zwqqwj

#切割 根据指定的分割符来进行分割，这里以逗号为例
name='jwq,qwj'
print(name.split(','))
#输出 ['jwq', 'qwj']

# capitalize 第一个字符大写，其他都小写
name='jwq,qwj'
print(name.capitalize())
#输出 Jwq,qwj

# lower 全部小写
name='JWQQWJ'
print(name.lower())
#输出 jwqqwj

# upper 全部转为大写
name='jwqqwj'
print(name.upper())
#输出 JWQQWJ

list

list=[1,2,'jwq',3]
print(list)
#输出 [1,2,'jwq',3]

# append 添加对象
list=[1,2,'jwq',3]
list.append('zhn')
print(list)
#输出 [1, 2, 'jwq', 3, 'zhn']

# extend 分散添加 添加的对象一定是可迭代的
list=[1,2,'jwq',3]
list.extend('zhn')
print(list)
#输出 [1, 2, 'jwq', 3, 'z', 'h', 'n']

# insert 下标添加 指定位置如果有元素，则元素后移
list=[1,2,'jwq',3]
list.insert(4,'zhn')
print(list)
#输出 [1, 2, 'jwq', 3, 'zhn']

# [] 通过下标修改
list=[1,2,'jwq',3]
list[0]=3
print(list)
#输出 [3, 2, 'jwq', 3]

# in not in 元素是否存在字符串中
list=[1,2,'jwq',3]
print(2 in list)
print(2 not in list)
#输出 True
#输出 False

# del 删除元素
list=[1,2,'jwq',3]
del list[1]
print(list)
#输出 [1, 'jwq', 3]

# pop 删除指定下标元素 默认删除最后一个
list=[1,2,'jwq',3]
list.pop(1)
print(list)
#输出 [1, 'jwq', 3]

# remove 删除指定元素
list=[1,2,'jwq',3]
list.remove(2)
print(list)
#输出 [1, 'jwq', 3]

# sort 排序 默认从小到大
list=[1,55,3,18]
list.sort()
print(list)
#输出 [1, 3, 18, 55]

# reverse 倒序
list=[1,55,3,18]
list.reverse()
print(list)
#输出 [18, 3, 55, 1]

#列表推导式
list=[]
[list.append(i) for i in range(1,6)]
print(list)
[list.append(i) for i in range(1,6) if i%2==1]
print(list)
#输出 [1, 2, 3, 4, 5]
#输出 [1, 3, 5]

元组

# 元组 只有一个元素时，末尾加逗号 元组只能查询，不可以增删改
tup=(1,2,3,'jwq')
print(type(tup))
#输出 <class 'tuple'>

字典

# 字典键是惟一的，值可以重复
dic={'name':'jwq','age':18}
print(type(dic))
#输出 <class 'dict'>

# [键名] .get(键名) .get这个键名不存在，返回None
dic={'name':'jwq','age':18}
print(dic['name'])
print(dic.get('name'))
#输出 jwq
#输出 jwq

# 修改键值
dic={'name':'jwq','age':18}
dic['age']=20
print(dic)
#输出 {'name': 'jwq', 'age': 20}

# 添加元素
dic={'name':'jwq','age':18}
dic['size']=20
print(dic)
#输出 {'name': 'jwq', 'age': 18, 'size': 20}

#删除元素
dic={'name':'jwq','age':18}
del dic['name']
print(dic)
#输出 {'age': 18}

# pop 删除指定元素
dic={'name':'jwq','age':18}
dic.pop('name')
print(dic)
dic.popitem() #3.7版本以前随机删除，3.7以后默认删除最后一个
print(dic)
#输出 {'age': 18}
#输出 {'name': 'jwq'}

#清空字典
dic={'name':'jwq','age':18}
dic.clear()
print(dic)
#输出 {}

#长度
dic={'name':'jwq','age':18}
print(len(dic))
#输出 2

# keys() 返回所有键名
dic={'name':'jwq','age':18}
print(dic.keys())
#输出 dict_keys(['name', 'age'])

# values() 返回所有键值
dic={'name':'jwq','age':18}
print(dic.values())
#输出 dict_values(['jwq', 18])

# items() 键值对以元组的形式
dic={'name':'jwq','age':18}
print(dic.items())
#输出 dict_items([('name', 'jwq'), ('age', 18)])

集合

# 定义空集合使用set() 集合具有无序性，每次运行都是随机打乱的，数字除外，集合无序是因为涉及hash表，数字为什么不变，是因为hash中数字是它本身，不能修改集合中的值，集合有唯一性，可以自动去重，集合只有添加和删除
s={1,2,3}
print(type(s))
#输出 <class 'set'>

# add 添加 一次只能添加一个元素
s={1,2,3}
s.add(4)
print(s)
#输出 {1, 2, 3, 4}

# update 把传入元素拆分，一个个放进集合，由于无序性，每次运行都不一样 元素必须是能够被我们for循环取值的可迭代对象
s={1,2,3}
s.update('456')
print(s)
#输出{1, 2, 3, '4', '6', '5'}

# remove 删除元素
s={1,2,3}
s.remove(1)
print(s)
#输出 {2, 3}

# pop 默认删除第一个
s={1,2,3}
s.pop()
print(s)
#输出 {2, 3}

# discard 有这个值就删除，没有不做改变
s={1,2,3}
s.discard(2)
print(s)
#输出 {1, 3}

# & 交集
s1={1,2,3}
s2={2,3,4}
print(s1 & s2)
#输出 {2, 3}

# | 并集
s1={1,2,3}
s2={2,3,4}
print(s1 | s2)
#输出 {1, 2, 3, 4}

类型转换

# int() 浮点型强转为整型，去掉小数点
age=12.2
print(int(age))
#输出 12

# float() 整型强转为浮点型，加小数点
age=12
print(float(age))
#输出 12.0

# str() 整型强转为字符型
age=12
print(type(str(age)))
#输出 <class 'str'>

# eval 计算字符串里面数字 它也是可以实现list、dict、tuple和str之间的转换
a=eval('10+10')
print(a)
print(type(a))
#输出 20
#输出 <class 'int'>

# list 支持转换成list的类型：str、tuple、dict、set
a=(1,2,3)
print(list(a))
#输出 [1, 2, 3]

深浅拷贝

# 深浅拷贝只针对可变对象（可变对象定义看下面）
# 浅拷贝 赋值内存地址是一样的
list1=[1,2,3,4]
list2=list1
print('list1:',list1)
print('list2:',list2)
list1.append(5)
print('list1:',list1)
print('list2:',list2)
#输出 list1: [1, 2, 3, 4]
#输出 list2: [1, 2, 3, 4]
#输出 list1: [1, 2, 3, 4, 5]
#输出 list2: [1, 2, 3, 4, 5]

# 浅拷贝 copy id的内存地址是不同的 嵌套列表中一起改变了，因为他们的内存地址是一样的
import copy
list1=[1,2,3,4,[5,6,7]]
list2=copy.copy(list1)
print('list1:',list1)
print('list2:',list2)
list1.append(5)
print('list1:',list1)
print('list2:',list2)
list1[4].append(8)
print('list1:',list1)
print('list2:',list2)
print('list1[4]:',id(list1[4]))
print('list2[4]:',id(list2[4]))
#输出 list1: [1, 2, 3, 4, [5, 6, 7]]
#输出 list2: [1, 2, 3, 4, [5, 6, 7]]
#输出 list1: [1, 2, 3, 4, [5, 6, 7], 5]
#输出 list2: [1, 2, 3, 4, [5, 6, 7]]
#输出 list1: [1, 2, 3, 4, [5, 6, 7, 8], 5]
#输出 list2: [1, 2, 3, 4, [5, 6, 7, 8]]
#输出 list1[4]: 2033598556040
#输出 list2[4]: 2033598556040

#深拷贝（数据完全不共享） 可以看到无论是外层还是内层都是不一样的
import copy
list1=[1,2,3,4,[5,6,7]]
list2=copy.deepcopy(list1)
print('list1:',list1)
print('list2:',list2)
list1.append(5)
print('list1:',list1)
print('list2:',list2)
list1[4].append(8)
print('list1:',list1)
print('list2:',list2)
print('list1[4]:',id(list1[4]))
print('list2[4]:',id(list2[4]))
#输出 list1: [1, 2, 3, 4, [5, 6, 7]]
#输出 list2: [1, 2, 3, 4, [5, 6, 7]]
#输出 list1: [1, 2, 3, 4, [5, 6, 7], 5]
#输出 list2: [1, 2, 3, 4, [5, 6, 7]]
#输出 list1: [1, 2, 3, 4, [5, 6, 7, 8], 5]
#输出 list2: [1, 2, 3, 4, [5, 6, 7]]
#输出 list1[4]: 1585437960072
#输出 list2[4]: 1585437961480

可变对象

# 定义：变量对应的值可以改变，但是内存地址是不变的
# 常见可变类型 list、dict、set，拿字典、集合举例
dic={'name':'jwq','age':18}
print(id(dic['name']))
dic['name']='zhn'
print(id(dic['name']))
set={1,2,3,4}
print(set,id(set))
set.remove(1)
print(set,id(set))
#输出 2547392693280
#输出 2547392693560
#输出 {1, 2, 3, 4} 2864694744904
#输出 {2, 3, 4} 2864694744904

不可变对象

# 定义：变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间
n=10
print(n,id(n))
n=20
print(n,id(n))
#输出 10 1855956352
#输出 20 1855956672