python学习笔记之基础

基础：

    python是一门高级编程语言

vscode编译：

       vscode编译器-------我的最爱

    如何书写python?

1 下载下图的python 插件

 2 F1键输入Python:Select Interpreter选择下载的编译器路径(前提：已经下载python了哦，下载地址Download Python | Python.org）

 温馨提示：

     如果想要使用pip下载第三方模块，python一定要使用3.9以及以下版本

    不然就下载失败了，我找了好久的下载wxpython模块失败的bug。。。。。。。。。。。

3 创建python 文件夹 创建一个.py结尾的文件

4 文件输入以下内容

msg = 'Hello World'
print(msg)          #打印

5 点击编译器右上角的按钮可以运行查看，如下图

或者鼠标右键点击Run  Python File in Terminal

学习python：

    1 很详细的python说明，不喜欢看视频的可以看这个

     2 B站python教程，比较适合基础小白

 基础部分：

   数据类型

             变量：

msg = '22222'       #变量
print(msg)          #打印
print(id(msg ))     #变量在内存中的地址

           常量：

MY=111          #常量，使用大写表示常量
print(MY)

          空值：

none  = None
print(n)           #None
print(bool(n))     #false

          布尔值：

Boolean = True    #直接定义
Bool = bool(True) #bool()内置函数定义布尔类型
print(Boolean)

b3 = bool(0)
b4 = bool(1)
print(b3)    # False==0
print(b4)    # True==1

         字符串：                

 #可以使用单引号'字符串',双引号'' 字符串''，三引号'''字符串'''
msg = '22222'       #字符串
print(msg)          #打印

        整数：

num = 3         #整数
print(num)      #打印

       浮点数：

num = 3.0       #小数
print(num)      #打印

      列表：

list= [10,20,30]
print(list)

     元组：

tuple = (10,20,30)               #直接赋值
tuple=tuple((10，20，30))        #tuple()定义元组
print(tuple)

#特性：
  1 数据不可改变性

       集合：

set= {10,20,30}        #创建方式一
set=set({10，20，30})  #创建方式二，创建空集合只能使用set()，也可以把其他类型的结构直接转换为集合
print(set)

#特性：
 1 数据无序性
 2 存储数据多样性
 3 数据唯一性

      字典： 

dict = {'name': '刘刘','age': 18}         #直接赋值
dict = dict({"name": "guan", "age": 13}) #dict()实例化dict变量

print(dict)

#特性：
  1 无序，没有索引
  2 键的唯一性，重复取最后的值
  3 键的不可变性
  4 元素可增删

检测数据类型：

num=555
print(type(num))

strs='3333'
print(type(strs))   #检测数据类型

my_dict = {}
print(type(my_dict))

    结果：

<class 'int'>         #整数
<class 'str'>         #字符串
<class 'dict'>        #字典

 数据类型转换：

strs='3333'
print(int(strs))    #转数字

num=555
print(str(num))    #转字符串
print(float(num)) #转浮点数（转小数）

list = [10,20]       
print(tuple(list1))  	 # 序列转元组

tuple= (100,200)
print(list(tuple)) 		# 元组转序列

#计算在字符串中的有效Python表达式，并返回一个表达式。
str3 = '1'
str4 = '2.1'
str5 = '(10,20)'
str6 = '[10,20]'
print(type(eval(str3)))   #  把字符串中的数据转换成他原本的类型 

     结果：

3333
555
555.0
(100, 200)
[100, 200]
<class 'int'>

变量命名：

     不能以数字开头

   1 驼峰命名法：除了第一个单词首字母小写，其它的单词首字母大写    

myName ='程序媛刘刘'      
print(myName )         

    2帕斯卡命名法：每个单词首字母大写

MyName ='程序媛刘刘'      
print(myName ) 

   3 蛇形命名法：每个单词由下划线字符分隔

My_Name ='程序媛刘刘'      
print(myName ) 

字符串操作：

strs='3333'
str1='ll'

print(len(strs))#求字符串中的长度

#大小写
print(int(strs))    #转数字
print(strs.upper())  #转大写
print(strs.lower())  #转小写
print(str1.title())  #首字母大写
#删除
print(str1.rstrip()) #删除字符串右端空格
print(str1.lstrip())  #删除字符串左端空格
print(str1.strip())   #删除字符串两端空格
#替换
print(str1.replace('替换','被替换'，次数))  #替换，返回修改后的字符串
                                 # 替换次数如果超出字串出席那的次数，表示替换所有这个字串
#特殊符号
print("my\n name\t is \n程序媛刘刘")  #制表符\t  换行符\n  添加空白

#数据合并
print("my name "+"is 程序媛刘刘")  #字符串拼接

print(strs*3)  #字符串相乘

list = ['aa','bb','cc']
new_str = '...'.join(list ) #join() 合并
print(new_str)
#查询
name = "hello world"
print(name.find('d'))       #find(sub [,start [,end]])找到字符串中最低字符索引号
                            #没找到，则返回-1
print(name.count('l'))      #count(sub[, start[, end]]) 返回某些字符出现的次数
                            #  有返回次数，无返回0
print(name.rfind('and'))  #rfind() 没找到，则返回-1
print(name.index('ands')) #index(sub [,start [,end]])
                          #存在，返回第一次出现的索引，不存在，报错
print(name.rindex('and')) #rindex()查询，下标0开始
print( max(str))            #数据中最大的成员,返回r
print( min(str))            #数据中最小的成员,返回空
                             #大小：中文字符>字母>数组>英文字符
                                  #中文按照拼音的首字母来计算

print(str .startswith('hell',0,10)) # startswith(字串，开始位置下标，结束位置下标)
                                    #判断字符串是否以某个字串开头，
                                    #开始位置下标和结束位置下标可以省略
print(str .endswith('world'))  # endswich(字串，开始位置下标，结束位置下标)
                               #开始位置下标和结束位置下标可以省略

#例子
str = 'www.dotcpp.com'
str.index('o',6,13)#在6-12之间寻找o
str.count('w',0,5)#统计w在0-4之间存在的次数
str.find('c',3,9)#在3-8之间寻找7

#截取
print(name.split(' '))     #split([sep [,maxsplit]]) 把字符串由分隔符返回一个列表
                           #如果给定maxsplit，则最多为maxsplit
print(name.split(' ',0))
print(name[0:2])      #截取0-1项
print(name[::2])      #步长为2 
print(name[::-1])     #逆置字符串

#判断
str = 'Hello World' 
str1 = 'Hello'
print( str1 in str)         #返回true
print( str1 not in str)     #返回false

#常用的测试方法
print(str .isalpha())    #isalpha():字母  纯字母才可以，如果中间有空格返回的false
print(str .isdigit())    #isdigit():数字，有空格返回false
print(str .isalnum())    #isalnum():数字或字母或组合，有空格返回false
print(str .islower())    #islower():小写字母，有空格返回false
print(str .isupper())    #isupper():大写字母，有空格返回false
print(str.isspace())	 #isspace():判断是否是空白(空格、换行（\n）和制表符（\t）)
                          #是返回True 

#对齐方式
str .ljust(10)             #左对齐
str .rjust(10)             #右对齐
str .rjust(10,'.')         #以点作为填充效果
str .center(10)            #居中
str .center(10,'.')        #填充空白

#遍历
for i in strs:
    print(i,end=' ')

for i in range(len(strs)):
    print(strs[i],end=' ')

 特殊符号：

\n 换行符
r  打印原始字符，有特殊符号不会执行
\t 制表符

 格式化输出：

   也可以说是字符串另一种拼接方式

方式一：符号

          f'{表达式}'

print(f'我的名字叫{name},我的年龄为{age}')

      %s(字符串）

name='程序媛刘刘'
print('我的名字是%s' %name)

    %d（有符号的十进制整数）

num=60000
print('未来工资期望：%d' %num)  

study=1
print('我的学号：%03d' %study)      #学号不够三位，其它用0 补全  

for i in range(5):
  print('%-5d'%i,end=' ')  #左对齐方式
  print('%5d'%i)           #右对齐方式  

 %f（浮点数）

num=6.00
print('期望评价：%f' %num) 
print('保留2位小数格式为:%.2f'%num)

 %c（字符） 

  

方式二：format()

str.format()
namea = '小明'
nameb = '小华'
print('{}是{}的好朋友'.format(namea,nameb))

#{[index[:[fill]align][width][#][.k][type]]}
  index    索引位置
           指定对象在列表中的索引位置，索引值从0开始，如果没有索引值，按从左到右的顺序
  ：       后续内容使用的前提，使用后面操作的时候都要加一个‘：’
  fill     选择一个参数作为空白填充的字符数
  width    选择一个参数来指定长度
  align    对齐方式，需要搭配width使用
           >  右对齐，
           <  左对齐
           =  右对齐
           ^  居中

   #      进制前缀
  .k      k是可选参数，表示小数点后保留的数字
  type    指定类型
          S   字符串
          D   十进制整数
          %   百分比
         f/F  浮点数

#右对齐，宽度为10，空白字符用符号@代替
 my_str = 'dotcpp'
 print('{:@>10}'.format(my_str)) #@@@@dotcpp


my_str = 'dotcpp'#先定义两个字符串
my_string = 123456.654321
print('my_str:{1:!^20s}\nmystring:{0:$^20.2f}'.format(my_string,my_str))

#输出结果
# my_str:!!!!!!!dotcpp!!!!!!!
# mystring:$$$$$123456.65$$$$$$

列表操作：

mList = [1, 2, 3, 4, 5]
#索引正数：0，1，2，3，4 
#    倒数：-5，-4，-3，-2，-1

mList = []                      #定义空列表 
                                  
my_list = list(range(1,11))     #list（）强制类型转换，把字符串或元组转换为列表；定义列表
print(my_list)                 #创建一个列表，列表中包含1~10的数字

print(1 in mList)    #  True   #判断是否包含元素，包含返回true，不包含返回false
print('13' in mList) # False

print(max(mList))  # 5         #返回列表最大的元素
print(min(mList))  # 1         #返回列表最小的元素

listing = ['a','b','c','d']
print(max(listing),min(listing)) #列表中字母的最大和最小值

#求和
my_list = [1,2,3,4,5,6]
print(sum(my_list))

#复制
first_list = [1,2,3,4]             #先定义一个列表
second_list = first_list           # 复制这个列表，此方式的id是一样的，一个改变另一个也会改变
print(id(first_list), id(second_list))  # 通过访问id可以发现此时两个列表地址是相同的
second_list = [] + first_list        #使用连接符
print(id(first_list),id(second_list)) #通过访问id可以发现此时两个列表是相互独立的


print(mList[0])    #1          #取值，按照索引[index]取值
print(mList.index('1')) #0     #取值所在的下标
print(mList.count('TOM'))     #count()，没有报错
print(len(mList))             # len() 列表的长度

print(mList.append('6'))       #末尾新增
print(mList.insert(1, '0'))    #insert(下标，数据)，指定位置插入
print(mList.extend(['7', '8']))#末尾插入列表里面所有元素
print(mList.copy())            #拷贝

print(mList[0]='1111')         #修改指定下标数据

print(del mList)               #删除整个列表
print(del mList[0])            #删除指定下标数据
print(mList.pop(1))            #删除指定下标数据返回该数据，没有参数，默认删除最末端元素
print(mList.remove('5'))       #删除自定元素
print(mList.clear())           #清空列表

print(mList.sort(key=None,reverse=False))  #排序，True是降序，False是升序
b=sorted(mList)
print(b)                                  #定义一个新列表来存放排序过的序列)

c = list(reversed(mList ))      #使用reversed逆序一定要加上一个存储类型
mList .reverse()                #使用reverse逆序
print(c,mList )

print(len(mList))             #计算列表的长度

#拼接：
my_list = [1,2,3,4,5,6,7,8,9,]
my_list2 = [11,22,33,44,55,66]
print('两个列表相加后为：',my_list+my_list2)

#相乘
print(my_list *3)

#切片(截取)
my_list = [1,2,3,4,5,6,7,8,9,]
print('取列表的前5项',my_list[0:4]) #简写 my_list[:4]
print('取列表的第2-4项',my_list[1:4]) #不包含4
print('取列表所有项，步长为2',my_list[::2])#步长为2 间隔为1
print('取列表的逆序',my_list[::-1]) #步长为-1时逆序

#初始化列表
my_list = [None] * 5  #实现一个长度为5的初始化列表
print(my_list)

#遍历
for i in range(len(mList)):
	print(mList[i])
i = 0
while i < len(mList):
    print(mList[i])
    i += 1

my_list = ['小明','小华','小天','小娜','小美','小李']
for index,element in enumerate(my_list):
    print('序号为：',index,'名字为：',element)

字典操作：

dict = {}

print(dict['age'] = 20)        #修改元素的value

print(dict['school'] = 'qh')   #新建/添加


#删除
dict .pop(name)                 #删除键为name的这一项
my_dict.pop(name,'no found')     #删除键为name这一项，如果找不到返回'no found'

print(del dict)                 #删除字典
print(del dict['name'])        #删除某个key值对应的item   
   
print(dict.clear())            #清空字典里的元素

print(len(dict))                #计算字典的长度

#查询
print(dict.get('name',6666))   #查询，存在返回value值，不存在返回参数2
                               #可以避免因未找到相应目标而引发异常的情况
print(dict.keys())              #返回可用for循环的对象的key
print(dict.values())            #返回可用for循环的对象的value
print(dict.items())            #返回可用for循环的对象的item


#拆分
dict={'name':'刘刘','age':18}
a,b=dict

print(a)          #name
print(b)          #age
print(dict1[a])   #刘刘
print(dict1[b])   #18

#是否存在
if name in dict :     #如果dict中存在name这个键就执行下面语句
       print(dict[name])

if age not in dict :  #如果dict中吧存在dict 这个键就执行下语句
       print('不存在age这个键')

#遍历
for key in dict.keys():
    print(key)

for i in dict.items():
        print(i)

for i,j in dict.items():
   print('对应键:',i,'对应值:',j)

字典常用函数： 

集合操作：

set={1,2,3}  

set.add(100)                  #增加元素，集合有去重功能
set.update([10,20,30,40,50])  #增加一个列表

10 in set                #判断元素是否在集合中，在，返回True
10 not in set            #判断元素是否在集合中，不在，返回True

print(len(set))#求集合中的长度

my_set = {1,2,3,4,5,6}
print(max(my_set),min(my_set))#求集合中的最大值和最小值

#求和
my_set = {1,2,3,4,5,6}
print(sum(my_set))
#运算
A = {'数学','语文','英语','物理','化学','生物'}
B = {'数学','语文','英语','政治','地理','历史'}
  #交集
   print(A & B)
   print(A.intersection(B))  #{'英语', '语文', '数学'}
  #并集
   print(A | B)
   print(A.union(B))   #{'英语', '物理', '语文', '政治', '化学', '数学', '生物', '地理', '历史'}
   #差集
   print( A - B)
   print(A.difference(B))  #{'物理', '生物', '化学'}
   print(B - A)
   print(B.difference(A))  #{'政治', '历史', '地理'}

set.remove(10)          #删除指定数据，没有则报错
set.discard(10)         #删除指定数据，没有不会报错
pop_return = set.pop() #随机删除数据并返回该数据
del my_set              #清空集合
set.clear()          #清空集合

len(set)               #计算集合的长度

元组操作：

tup1 = (12,34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2    #(12,34.56,'abc','xyz') #拼接元组

tupl = ()             #创建空元组
tup1[0] = 100          #修改元组是非法的
  #修改方式
    #1.重新赋值
     tup1 = (11,22,33,44,55,66,77)
     print(tup1)
    #2 转换为其他类型修改，修改成功后在进行转换为元组
    my_tuple = (1,2,3,4,5,6)
    my_tuple = list(my_tuple)#把元组转换为列表形式
    print(my_tuple,type(my_tuple))#看一下现在的数据和类型
    my_tuple.insert(3,'插入新元素')
    my_tuple[3] =['元素更改-------']
    my_tuple.pop()#元素的删除，pop()删除最后一项
    my_tuple = tuple(my_tuple) #最后转换为元组形式
    print(my_tuple,type(my_tuple))

tup1 .index('aa')     # index（，，查找范围）没找到直接报错。
tup1 .count('aa')    # 计算出现次数
print(tup1*3)        #元组相乘

my_tuple = (1,2,3,4,5,6)
print(max(my_tuple),min(my_tuple))#求元组中的最大值和最小值

#求和
my_tuple = (1,2,3,4,5,6)
print(sum(my_tuple))

del tup1       #删除元组
len(tup1)      #计算元组长度
tup1[0]       #访问元组里的元素

10 in tup1     #判断元素是否在元组中，在，返回True
10 not in tup1 #判断元素是否在元组中，不在，返回True

序列的内置函数总结： 

   

运算符：

运算符	作用	实例
+	相加	num+num
-	相加	num-num
*	相乘	num*num
/	相除	num/num
%	取模	num%num
**	幂	num**num num的num次幂
//	取整除	num//num
=	赋值	num=str
==	相等	num==num
！=	不等于	num！=num
+=	加法赋值	num+=str----num=str+num
&	与	num&str
|	或	num | str
and	布尔类型与	num and str
or	布尔类型或	num or str
not	布尔类型非	not num
is	判断两个标识符是否引用同一个对象	num is str
is not	判断两个标识符是否引用不同对象	num  is not str
^	异或	num^ str
~	取反	~num
<<	左移动	num << 3
>>	右移动	num>> 3

推导式 ：

  列表推导式

#列表推导式

#普通写法

listname = []
for i in range(10):
   listname.append(i)
print(listname)

listname = [1,3,5,6,7,9,10,23,26,28,64,98]
for i in range(len(listname)):
      listname[i] += 5
print(listname)

listname = [10,20,30,40,60,120,130,140,160,180,200]
newlist = []#创建新列表来存储
for i in range(len(listname)):#索引值遍历
    if listname[i] >100:#找到大于100的数
        listname[i] *= 0.8#乘上0.8
        newlist.append(listname[i])#添加到新列表中
print(newlist)

my_list = []#先创建一个主列表
for i in range(6):#循环遍历6次，依次为主列表的每个元素创建新的列表
    j = []#先创建新列表并添加入主列表中
    my_list.append(j)
    for m in range(1,7):
        j.append(m)#为子列表添加元素
print(my_list)#输出
#推导式写法：
listname = [i for i in range(10)]

listname = [1,3,5,6,7,9,10,23,26,28,64,98]
listname = [ i + 5 for i in listname]

listname = [10,20,30,40,60,120,130,140,160,180,200]
newlist = [i*0.8 for i in listname if i > 100]
print(newlist)

my_list = [[i for i in range(1,7)] for j in range(1,7)]
print(my_list)

 字典推导式： 

 #字典推导式

my_dict = {i:'dotcpp' for i in range(1,5)}
#{1: 'dotcpp', 2: 'dotcpp', 3: 'dotcpp', 4: 'dotcpp'}

my_list = [10,20,30,40,50]
my_dict = {i:my_list[i] for i in range(1,5)}
#{1: 20, 2: 30, 3: 40, 4: 50}

输入框：

name = input()
print('Hi',name)

print('Hello World', end='')      #end结尾内容
print('This is content',end='。。。。')

在终端输入name值，就可以获取到结果，例如下图

常用语句：

        判断语句：

#if
if True:
    print('win')
#if else
age =int( input('请输入您的年龄：'))
if age >= 18:
    print(f'{age}，可以上网')
else:
    print(f'{age}，小朋友')
#if elif
age = int(input('请输入您的年龄'))
if age < 18:
    print(f'{age}，童工')
elif (age >= 18) and (age <= 60):
    print(f'{age}，合法')
elif age > 60:
    print(f'{age}，退休')
#if 嵌套
money = 1
seat = 0
if money == 1:
    print('请上车')
    # 判断是否能坐下
    if seat == 0:
        print('请坐下')
    else:
        print('请稍等')
else:
    print('未付钱')

   循环语句：

#while
i = 1
result = 0
while i <= 100:
    result += i
    i += 1
print(result)

#while else
i = 1
while i <= 5:
    if i == 3:
        break
    print('win')
    i += 1
else:
    print('refuse')
#while嵌套
j = 0
while j < 5
    i = 0
    while i < 5:
        print('*', end='')
        i += 1
    print()
    j += 1
#for
str1 = 'chengxuyuanliuliu'
for i in str1:
    if i == 'e':
        break
    print(i)
#for else
str1 = 'chengxuyuanliuliu'
for i in str1:
    print(i)
else:
    print('refuse')

break语句：

#break语句主要用于强制退出当前循环，它可以使用在while和for的控制语句中
#break语句大多会和if语句配套使用，跳出当前循环

for 变量 in 对象：#break语句在for语句中的用法
     if 条件语句：
         break
     循环语句
 while 条件语句：#break语句在while语句中的用法
     循环语句
     if 条件语句：
         break

#例子：
for i in range(100):#循环本要进行一百次
     if i == 5:#break控制在当i=5的时候退出循环
         break
     print(i)#当i=5的时候并没有打印，因此最后一位为4

 number = 0#定义number为0
 while number != 10:#当number不为10的时候进入循环
     print(number)
     number += 1#number在循环中每次+1，会到number=10的时候执行else语句
     if number == 5:#当number=5的时候跳出循环
         break
 else:
     print(number,'等于10')

continue语句：

#continue语句：终止本次循环，跳过尚未执行的语句而进入下次循环，可以用于for语句和while语句当中

for 变量 in 对象：#break语句在for语句中的用法
     if 条件语句：
         continue
     循环语句
 while 条件语句：#break语句在while语句中的用法
     循环语句
     if 条件语句：
         continue

#例子：
 number = 0
 while number != 10:
     number += 1
     if number == 5:
         continue
     print(number)#在number=5的时候此项被跳过
 else:
     print('number=',number)

 pass语句：

#pass语句：没有任何功能，是一个空语句，一般被用于充当占位的作用

for i in range(100):
     if i == 50:
         pass

三元表达式：

#if  + 条件  + else + 结果
result='gt' if 1>3 else 'result'
print(result)