右耳零基础学习Python详细笔记

很多人想学习语言编程，python作为当下最火的，简单，开源友好被大部分人所接收。大二上学期，我校就开展了这一们课程。同学们也是学的云里雾里，我也是一样，被这些简单的东西所折磨这。大学课时少，老师赶进度，而且老师也没有多少开发经验。我就自己开始寻找如何入坑Python,这里我推荐金角大王Alex的课程我是跟着他，一步步入圈。在这里我记录一下学习的内容与大家分享自己的学习进程。一起加油！！！

一，认识Python

1.1什么是编程语言

1.什么是编程，什么是编程语言？
编程：用代码编写程序
编程语言：用某种语法规则来编写程序
a=10=====>0101010(放在exe可执行文件)

2.编程语言分类
     1.编译型：c,go
       一次性把源代码进行编译（）
   特点：执行效率很高，平台依赖性较强(但是java语言特殊)
   2.解释型：javascript,python,ruby
   逐行对源代码进行编译和运行
   特点:执行效率相对较低，平台的依懒性不高

1.2下载Python,PyCharm

1.安装python
打开官网 https://www.python.org/downloads/windows/
注意选择添加Python到当前用户环境变量里
2.安装pycharm
打开pycharm官网
3.python和pycharm区别
Python是个解释器，pycharm是为Python编程语言专门打造的一款IDE（集成开发环境）。在pycharm中编写Python程序，
最终还是要有Python解释器的支持，两者配合工作。

单独下载一个pycharm是不行的，同时还要下载一个python解释器。

1.2写下第一个Python代码

1.编写第一个程序HelloWorld
执行Python代码可以通过2种方式
一种是在Python交互器里直接写
print("HelloWorld")
一种是写到文件里保存执行,不需要进入python肚子里面而是在命令行输入python 文件名
相当于python解释器 py.文件====》这就是执行python程序

1.3注释

1.注释：是对代码进行解释和说明
2.单行注释：#
3.多行注释''''''
""" """1.

1.4变量

1.变量：可以发生改变的一个量，变量用来区分不同数据，可以指向一个内存空间，帮我们存储一些数据
        a=10
       b=20
2.变量的命名规范：
    1.数字，字母，美元符号，下划线组成
   2.不能是数字开头
   3.关键字不能作为变量名
   4.不建议用中文

1.5常量

1.常量
print(123)#这个123就是常量，值是不可以改变的
PI=1234567890;
一般认为变量名大写为常量，没有绝对常量

1.6基本数据类型

数据类型：区别不同的数据，不同的数据类型有不同的操作
数字：+-*\
    整数：int
   小数：float
   a=10
   b=10
   print(a+b)#加号两边是相同的数据，这一点和java不同

文字：
str
表达方式：''

                  ""
                  """"
                  """"""
两边必须都是字符串表示字符串的连接
一个字符串只能乘以一个数字，表示字符串重复的次数

布尔bool：条件判断
True false
1 0

1.7用户交互

b=input('请在输入一个数字：')
input(提示语)这是一个等待的命令，输入的东西会被默认为字符串
print(a+b)
#用type()来看变量的数据类型
type(a)#字符串类型
####怎么把在字符串转化成数字
int(str)
a=int(a)#这样就可以变成加法运算
目前还不能把文字变成数字，这是一件很愚蠢的事情

二，运算符

2.1算数运算

%（求余数）

//（求商）

2.2逻辑运算

and（两边都成立才成立）

or（两边有一个成立才成立）

not（取反）
顺序:先算括号，not,and, or

扩展：

两边都不是0的情况：
and 直接取后面的值

or 直接取前面的值
如果存在0的情况：
and 直接取0

or 直接取非0

3 and 5 ===>5
3 or 5 ====>3
3 or 0====>3
3 and 0===>0

2.3位运算

和   位与运算符
|      位或运算符
^   位XOR运算符
〜   位补码运算符
<<   位左移运算符
>>   位右移运算符

1.按位与运算符 (1. Bitwise AND Operator)相同返回1，不同返回0
如果两个位均为1，Python按位运算符将返回1，否则返回0。
10转为二进制1010
7转为二进制111
1010
0111
同一为1，不同为0
0010转为十进制2

2.按位或运算符
如果任何位为1，Python按位或运算符将返回1。如果两个位均为0，则它将返回0。
>>> 10|7
15
>>>
10转为二进制1010
7转为二进制111
1010
0111
有1则1，全0则0
1111转为十进制15

3.按位XOR运算符（位异或）相同返回0，不同返回1
如果位之一为0，另一位为1，则Python按位XOR运算符将返回1。如果两个位均为0或1，则它将返回0。

>>> 10^7
13
>>>
10转为二进制1010
7转为二进制111
1010
0111
1101转为十进制13

4.按位补码运算符（位求反）

Python Ones的数字'A'的补码等于-（A + 1）。

>>> ~10
-11
>>> ~-10
9
>>>
10转为二进制1010
~10--->~1010
-(1010+1)=-(1011)=-11

5.按位左移运算符
Python按位左移运算符将右操作数中的给定次数向左移动左操作数位。简而言之，二进制数末尾带有0。

>>> 10 << 2
40
>>>
10变成二进制1010后面补上两个0
变成101000转为十进制变成40

6.按位右移运算符
Python的右移运算符与左移运算符完全相反。然后将左侧操作数位向右侧移动给定次数。简单来说，右侧位已删除。

>>> 10 >> 2
2
>>>
10变成二进制1010后面删除两个值
变成10转为十进制变成2

2.4比较运算

2.5赋值运算

*=
a=20
b=80
#要求a=80,b=20
tem=a#把a的值存起来
a=b
b=tem
print(b)
print(a)
#但是在Python中更为方便的是
a,b=b,a

2.6成员运算

in 判断是否出现
not in

三，选择结构

3.1第一种

#if 条件：
   #代码
#如果条件成立执行代码，否则不执行
money=500
if money>800:
   print(123)#因为python，没有大括号所言，所以用缩进来规范语法
   print(234)
print(789)

3.2第二种

'''
if 条件：
代码
else:代码

'''
money=input("请输入兜里的钱：")
money=int(money)
if money>500:
print("吃饭")
else:
print("回家")

3.3第三种

'''
if语句可以互相嵌套
if 条件:
   if tioajian:
       代码
   else:
       daima
else:
   daima

'''
money=input("请输入兜里的钱")
money=int(money)
if money>2000:
   if money>3000:
       print("冲一个会员卡")
   else:
       print('洗脚就好')
else:
   print("回家吧孩子，你太穷了")

3.4.第四种

'''
if 条件:
   daima
elif 条件:
   daima
elif 条件:
   daiam
else:
   daima

'''

四，循环结构

4.1for循环

4.1.1for循环可以用来遍历可迭代的对象

# for 变量 in 可迭代对象

s="你好啊！"
for c in s:
print(c)

4.1.2for也可以用来数数，但是要借助range函数

i=1
for i in range(10):
print(i)
#1~10但是不包括10
range(m,n)从m到n但是不包括n
range(m,n,s)从m到n，间隔s

4.2while循环

4.2.1死循环

while(true):
print("你好")

4.2.2用程序去数数，从1~100

sum=0
i=1
while(i<=100):

   sum=sum+i#累加
   i+=1

print(sum)

五，循环常用关键字

continue

break

while True:
   content=input("请输入要说的话:")
   print("发送给下路",content)
#程序不会自己结束
while True:
   content=input("请输入要说的话（q结束对话）:")
   if content=="q":
       break #结束的是当前循坏
   print("发送给下路",content)
@@@@continue
i=1
while i<=10:
   if i==4:
       i=i+1
       continue#终止当前循环
   print(i)
   i=i+1

六，pass

pass是一个关键字,占位
a=10
if a>100:
pass#这个地方不知道要说什么先过掉之后补上，防止代码报错

七，基本数据类型

7.1int,float,bool

int 整数，加减乘除，大小比较
float:小数，浮点数
print(10/3)#小数的范围是无限的，整数在一个特定范围内是有限的
计算机表示一个小数是有困难的，有误差
bool:用来做条件判断
取值True false

7.1.1基础数据类型之间的转换

a="10"
print(type(a))
b=int(a)

a=9
print(type(a))
b=bool(a)
print(b)#true
#在python当中所有非零数字都是True
c=""
print(bool(s))#false
#在python当中所有空的都是false
eg:
while 1:
   content =input("请输入你要说的话")
   if content:
       print("这是发给下路的",content)
   else:
       break

7.2str

7.2.1字符串格式化问题

name=input("请输入你的名字:")
address=input("请输入住址:")
age=int(input("请输入你的年龄"))
hobby=input("请输入你的爱好")
# %s字符占位,他是万能占位符
# %d占位整数
# s="我叫%s,我住在%s,我今年多少%d岁，我喜欢做%s"%(name,address,age,hobby)
# print(s)
# s1="我叫{}，我住在{}，我今年{}岁，我喜欢{}".format(name,address,age,hobby)
# print(s1)
s2=f"我叫{name}，我住在{address}，我今年{age}，我喜欢{hobby}"# f-string
print(s2)
-----------------------------------------------------------

7.2.2索引和切片

索引：按照位置提取元素
s=“我叫裴家奇"
采用索引提取一个字符
print(s[3])
#程序员是从0开始数数的
print(s[-1])#倒数第一
切片：从一个字符串中提取一部分内容
s="我叫youer，我可以住宅"
print(s[3:6])#从 3位置开始，切片到6位置结束，切片拿不到第二个元素

#语法 s[start,end],从start开始切，到end结束，但取不到

print(s[:5])#从0到位置5结束
print(s[1:])#从1到结尾
print(s[:])#全部s输出

#切片只能从左往右

print(-3:-2)
#可以添加步长控制切片方向
print(s[::-1])#-表示从右往左走
语法：s[start:end:step]从start切到end,每step个元素出来一个元素
切片也可以增加元素
开头增加s[:0]=[1,23,3]
尾部增加s[len(s):]=[1,2,3]
-------------------------------------------------------

7.2.3字符串的常规操作

#字符串的操作一般不会对原字符串产生影响，一般是返回一个新的字符串
s="python"
s1=s.capitalize()
print(s1)#Python

s="I have a dream"
s1=s.title()
print(s1)#I Have A Dream单词的首字母大写

s="IHAVE"
S1=s.lower()#把所有字母变成小写
print(s1)

s="huahsh"
s1=s.upper()#把所有字母变成大写
print(s1)
#如何忽略大小写进行判断==》upper
verify_code="ADhuhk"
user_input=input(f"请输入验证码({verify_code}):")
if verify_code.upper()==user_input.upper():
   print("验证码正确")
else:
   print("验证码不正确")
strip()切割字符串两端的空白符（空格，/t,/n）
s=" 你也好，我叫裴 "
s1=s.strip()
print(s1)#你也好，我叫   裴家奇
#按例
username=input("请输入用户名：")
password=input("请输入密码:")
if username.strip()=="admit":#避免用户在输入的时候多按空格
    if password.strip()=="123456":
        print("登陆成功")
    else:
        print("失败")
    pass
else:
    print("失败")

replace(old,new)字符串替换
s="你好啊,我叫裴家奇"
s1=s.replace("裴家奇","sai")
print(s1)

split()切割,切割后剩余的字符用列表装起来
a='python_java_sdfdfsdhj'
s1=a.split("_java_")
print(s1)#['python','sddhjaj']

5.字符串查询，判断
in
find
index
S="你好啊,我叫裴家奇"
s1=s.find("裴家奇")
print(s1)#6
s2=s.find("husdh")
print(s2)#-1找不到

s1=s.index("裴家奇")
print(s1)#6
s2=s.index("duihdi")
print(s2)#报错

s1="裴家奇” in s
print(s1)#True

判断
startwith endwith
s.startwith("你好")#判断s是否以该字符为首
isdigit()判断字符串是否由整数组成
isdecial()判断字符串是否由小数组成
money=input("请输入你的钱：")
if moeny.isdigit():#避免了输入其他字符而报错
   money=int(money)
   print("你可以花钱")
else:
   print("对不起，你输入有误")
6.补充
s="hello"
print(len(s))#len是一个内置函数，表示字符串的长度

a="Alex Li 金角大王"
print(a.center(60,"-"))------------------------Alex Li 金角大王------------------------
print(a.count("l"0,4)) 1

join()和split()相对的，表示拼接
s=['赵本山','xiyouji]
s2="用什么东西拼接".join(s)
print(s2)

====================================================

7.2.4总结：

1.f"{变量}"格式化一个字符串,"%s"%(变量)，"{}".format{变量}
2.索引和切片
按照位置提取元素用[],切片是提取字符串的一部分[:]
3.函数（java里面称为方法）
   1.upper(),captitalize(),little(),lower()
   2.strip(),切割字符串两端的空白
   3.split()，用某种特定的规定去切割，切割后剩余的元素用列表装起来
   4.replace()用于字符串，某些元素的替换
   5.join()
   6.startwith()
   7.len()注意这是一个内置函数，不需要引用调用

4.字符串的循环和遍历
for x in s:
print(x)
#遍历s中的每一个字符
关于in
1.判断
2.for循环

7.3list

7.3.1定义：能装东西的东西

在Python中用[]表示列表，列表中的元素通过，隔开
a=['zazh',"peijaiqi",[1,2,3]]
特征：和字符串一样也有索引和切片
      索引如果超出范围会报错
      可以用for循环进行遍历
      用len可以拿到lst的长度
lst=['金茂史昂'，"张三丰","裴家奇"]
print(lst[1])#索引
print(lst[1:2])#切片['张三丰']
print(lst[465])#lst index out of range
for c in lst:
   print(c)#遍历
print(len(lst))#列表的长度
========================================

7.3.2列表的增删改查

#向列表中增加内容
   lst=[]
           1.append()追加到列表的后面,单个元素
   lst.append(1)
   lst.append(2)
   lst.append("年后")
   print(lst)
           2.insert()插入，任意位置，索引为你插入该值位置前面
   lst.insert(1,"裴家奇")
   print(lst)

           3.extend()延伸，可以直接添加列表
   lst.extend([1,2,3])
   print(lst)
#删除
1.pop()#用序号,默认删除最后一个元素
lst.pop(0)# ret=lst.pop(0)
print(lst)
print(ret)#返回删除元素的值
2.remove()#直接删除元素
lst.remove(1)
#修改
lst[2]="家奇"#直接用索引就可以修改操作
print(lst)

#查询
print(lst[2])#直接用索引进行查询

#做一个小程序把龙性改成裴性
lst=["裴家奇",'易礼勇','龙建','''龙飞''']
for c in lst:#对列表进行遍历
   if c.startswith("龙"):#判断是否以龙为首
       newName="裴"+c[1]#字符串的拼接
       print(newName)
#以上只是简单的吧龙改成裴性

思考怎么样把修改过得值，放回列表中
# 需要把新名字丢回列表，以上循坏看不见索引序号，不知道第几个遍历出来的是我们想要的东西，于是需要遍历配合索引号

lst=["裴家奇",'易礼勇','龙建','''龙飞''']
for l in range(len(lst)): #最好range(len())，range(5)0~5但不包括5，用于遍历索引号
    c=lst[l]#使列表里面的值有了自己的编号
    #c=lst[0]=裴家奇
    # c=lst[1]=易礼勇
    # c=lst[2]=龙建
    # c=lst[3]=龙飞
   if c.startswith("龙"):
       newName="裴"+c[1]
       print(newName)
       lst[l]=newName#修改列表中的值
print(lst)
=====================================

7.3.3排序，列表是有顺序的

lst=[122,522,12,45]
#print(lst.sort())#不能这样写他不是一个内置函数
lst.sort()#对lst进行升序排序，默认
lst.sort(reverse=True)#进行降序排序

7.3.4列表的嵌套，他是一个可以装东西的东西

lst=["陪驾","你好","我是",["儿子","妈妈"],"爸爸"]
print(lst[3][0])
# lst=["陪驾","你好","我是",["儿子","妈妈"],"爸爸"]
# print(lst[3][0])
# lst[3][0]=lst[3][0]="jaiqi"
# print(lst[3][0])
#一层层的去找如同数组一样

lst=["裴坚强","裴英奇","于中证","大头","裴家奇"]
vacant=[]#设置一个空列表用于存储要删除的数字
for l in lst:
    if l.startswith("裴"):
        vacant.append(l)#把要删除的数字添加到空列表中
        # lst.remove(l)
for j in vacant:#把要删除的东西遍历出来
    lst.remove(j)#在原列表中删除遍历出来的东西
print(lst)
print("-------------------------------------------")

lst=["裴坚强","裴英起","于中证","大头","裴家奇"]
for l in lst:
if l.startswith("裴"):
lst.remove(l)
print(lst)
# 时元素时删除时后面的元素补上，for循环进入下一次这样就漏了元素，这个代码没有上面的完美

a=["遍历1","遍历2","遍历3",1,2,3]
for l in a:
print(l)

a=["遍历1","遍历2","遍历3",1,2,3]
for l in a:
   print(l)
#想遍历值得同时把下标打印出来
#枚举
for j in enumerate(a):
    print(j)
    print(j[0],j[1])#利用索引把元素里面的值拿出来

7.4tuple

# tur=("年中","年前","年后")
# tur[1]="peijaiqi"# 'tuple' object does not support item assignment
# print(tur)
#元组里面的元素不可以改变，里面若只有一个元素要加一个逗号
tui=(123,)
print(type(tui))
#元组增删改不存在
a=(1,2,3,[12,23,33])#不可变是元组里面的元素的内存地址是不可以改的，列表本身是可以增添元素的
a[3].append(123)
print(a)

7.5set

7.5.1基础认识

#set集合是无序的
s={}
print(type(s))#dict
a={1,2,3,[]}
print(a)#报错列表是不可哈希的，集合里面的数据要求是可以哈希的
#set集合在存储数据的时候需要对数据进行哈希计算，根据算出来的哈希值进行存储数据
不可哈希：可变的数据类型set,list,dict
可哈希：不可变得数据类型：tuple,str,int,bool,
创建一个空集合：s=set()
创建一个空列表：s=list()
创建一个空元组:s=tuple()
创建一个空字符：s=str()
s.add("加油")#增添
s.pop()#删除默认最后一个，基本无用
s.remove()
修改：先删除，在增加。因为没有索引不可以确定元素
s.remove("jiyou")
s.discard("jiayou")
s.add("nihao")
查询：只能通过for循环进行查询

7.5.2交集，并集，差集

s1={"1",2,3,4}
s2={1,2,3,4}
print(s1&s2)#交集
print(s1|s2)#并集
print(s1-s2)#差集

7.5.3集合的重要作用是用于去除重复

lst=[1,2,3,4,4,5,6,7,8]
print(set(lst))

7.5.4集合之间关系

a= [1,2,3,4,5]
b=[1,2,3]
set(a)>set(b) #验证b是不是a的真子集
set(a)>=set(b) #验证b是不是a的子集

#结果
True
True

7.6dict

7.6.1介绍

#字典是以键和值的方式去存储数据
#字典的表达方式{key1:value1,key2:value2}
dic={1:2,2:3}
val=dic[1]#用起来只是把索引变成key
print(val)
字典的key必须是可哈希的，value没有要求
dic={[]:"nihao"}
print(dic)# unhashable type: 'list'
--------------------------------------------------------

7.6.2增删改查

#增添
dic=dict()

dic={}
dic["好人"]="pei"#增加
dic["好人"]="jiaqi"#因为键里面已经有了元素，那么再次声明就是对里面元素的修改
dic.setdefault("好人"，"裴家奇")#给键“好人”设置默认值，如果里面已经有了元素，那么这是setdefault就不起作用

#删除
dic.pop("好人")#根据键去删除元素
del dic["好人"]#一般不用

#查询
print(dic['jay10089'])#如果键不存在，程序报错，一般用在知道键
print(dic.get('jay1999'))#不存在，不会报错，返回None.一般用在键不知道的情况

dic={"张三":"已经得到呈现",
     "王五":"一盒馒头",
     "裴家奇":"上了大学"
     }
name=input("请输入一个名字:")
val=dic.get(name)
if val is None:
    print("没有这个人")
else:
    print(val)

   -------------------------------
dic={"张三":"已经得到呈现",
     "王五":"一盒馒头",
     "裴家奇":"伤了大学"
     }
for l in dic:
    print(l)

对一个字典的遍历是得到他的键

dic={"张三":"已经得到呈现",
     "王五":"一盒馒头",
     "裴家奇":"上了大学"
     }
for l in dic:
    print(l,dic[l])#通过键去查询得到键里面的值
此方法官方推荐，效率更高

# 希望把所有的key都保存在同一个列表中
print(dic.keys())#dict_keys(['张三', '王五', '裴家奇'])
print(list(dic.keys()))

# 希望把所有的value都放在同一个列表中
print(dic.values())#dict_values(['已经得到呈现', '一盒馒头', '伤了大学'])
print(list(dic.values()))

--------------
#直接拿到字典中key和value
print(list(dic.items()))

dic={"张三":"已经得到呈现",
     "王五":"一盒馒头",
     "裴家奇":"伤了大学"
     }

print(list(dic.items()))类型的转换

for s in dic.items():
print(s)#变成了元组类型
print("-------------------------------------------------------------------------------------")

for key,value in dic.items():
print(key,value)
a,b=1,2,#元组和列表都可以执行该操作，该操作名字为解包
#ValueError: too many values to unpack (expected 2)a,b=1,2,3
print(a)
print(b)

for l in dic.items():
key,value=l
print(key,value)

7.6.3字典的嵌套

wangfeng={
    "name":"王峰",
    "age":16,
    "wife":{
        "name":"章子怡",
        "hobby":"电影",
        "age":12,
        "assistant":{
            "name":"樵夫",
            "hobby":"看菜",
             "age":12

        }
    },
    "children":{
        "child1":"datou",
        "child1":"xiaoty",
        "child1":"lisi"

}

}
print(wangfeng["wife"]["assistant"]["age"])#字典的查询wangfeng[key]