python学习笔记——python基本语法_str = "我是%s,期末考试数学成绩为%f!,语文成绩为%d!" % ('佩奇', 98.5,9

1.注释

给代码添加讲解，供程序员查看

单行注释：#开头+空格+内容

多行注释：三对引号：'''内容''' ;单引号注释只能嵌套双引号，或双引号注释只能嵌套单引号

2.输出

 输出功能：print(要输出的内容)
 ​
 #print功能详解
 print(*args,sep='',end='\n',file=None)
 *args   表示可以输出多个数据，数据中间用逗号‘，’隔开
 sep=''  表示输出多个数据时，数据与数据之间的分隔夫默认是空格
         12 34 56 88
         print(12, 34, 56, 88,sep='+')--->12+34+56+88

 end='\n'表示输出完毕后默认换行 
                                          #print(内容，end='')可以取消换行操作
     \ -- 在编程语言中成为转义符 可以改变一些符号的含义
         \n --- 换行符
         \t --- 制表符  tab键
         \r --- 回车
         \f --- 换页符
         \v --- 纵向制表符...

 file=None  设置输出内容的目的地
     要将数据输出到文件中，需要在程序中打开文件：open('文件路径'，'文件操作模式'，encoding='文件编码')
    
    文件操作模式：
         r --- read  只读内容
             打开一个原有文件，没有这个文件会报错
             只可读不可写，可以调节位置去读
         w --- write  只写内容  
             创建一个新文件文件/正常打开一个原有文件且清空原有文件内容
             打开文件时，内容就被清空。可以调节指针位置去写。
         a --- append  追加内容 
             创建一个新文件文件/正常打开一个原有文件
             不覆盖原文件内容。只在末尾追加内容，无法改变写的位置
     用法：
     print(内容，file=open('文件路径'，'文件操作模式'，encoding='文件编码'))

例：

name=input('姓名是:')
chinese1=float(input('语文成绩是:'))
math1=float(input('数学成绩是:'))
all_=chinese1+math1
print('期末考试,%s 的语文成绩是 %.2f，数学成绩是 %.2f，总成绩是 %.2f'(name,chinese1,math1,all_))
#输出所得的值
print('期末考试,%s 的语文成绩是 %.2f，数学成绩是 %.2f，总成绩是 %.2f'% 
 \(name,chinese1,math1,all_),file=open('E:/study/creat_test/%s的成绩单','w'))
#将得到的值输出到指定位置指定文件中
print('期末考试,%s 的语文成绩是 %.2f，数学成绩是 %.2f，总成绩是 %.2f'%
 \(name,chinese1,math1,all_),file=open('./%s的成绩单.txt','w',encoding='utf-8'))
 #在当前目录下创建一个txt文件，并将所得值写入文件中
 #  此处\表示换行

3.变量

 1.声明变量的方式：
     单个变量
         变量名 = 值
     声明多个变量：
         多个变量是同一个值：
                 变量名1=变量名2=变量名3=值
         多个变量的值不同
                 变量名1，变量名2，变量名3=值1，值2，值3
                 或者：
                 变量名1 = 值1
                 变量名2 = 值2
                 ..........

注：在使用一个变量的值时需要提前定义

 2.检验数据类型
     type(数据)    获取数据类型
         print(type(1))-----> <class 'int'>
     isinstance(数据，类型)   判断数据是否是指定类型
         M=1
         isinstance(M，str) ---> True或False  注意是大写

 3.标识符与关键词
     标识符由字母，数字，下划线组成
         规则：1.不能以数字开头
              2.不能用关键词
 4.变量名命名规范：
      1.单词与单词之间用下划线连接  例如：hello_word
      2.不要使用不是关键词但具有其他功能的词，否则自定义的数据会把之前的功能覆盖掉，再使用之前的功能就会无        法实现
 5.python文件名命名规范：
      1.尽量使用小写英文字母，单词之间用下划线连接
      2.不要用系统提供的工具名命名（会把原有的覆盖掉）
 6.项目命名规范：
      使用大驼峰制 每个单词的首字母是大写的
      
                             Python使用 UTF-8 编码格式编码

4.数据类型概述

 基本数据类型：整型 int   浮点型 float   布尔型  bool   字符串 string  空类型NoneType

 整型 int ：对整数数据的归档  
浮点型 float ：对小数数据的归类  
布尔型 bool：对逻辑状态成立与否的归类 这个类型只有两个值 True和False  
字符串 str ：对文本形式的数据进行归类，此类数据需要引号包含，表明该数据无需计算机计算其中内容，直接存储呈现  
空类型NoneType：没有实质意义的数据 只有一个值None【定义变量的时候 赋予初始值时不明确具体该赋予什么数据但 是这个变量又被使用 可以初始化为None】

 序列类型：
         他是容器类型数据，可存放多个数据

计算长度：len(str/tup /dict/list)

4.1.字符串 str：

 元素就是字符，长度为1的字符串就是字符
 特点：添加和显示顺序一致，可通过编号获取指定位置的元素，是一个有序的不可变序列
 表示元素位置的编号，也称为索引、下标、脚标
 编号的形式：
     从左开始：0  1  2  3  4  5  6  7  8
              h  e  l  l  o  w  o   r  d
     从右开始  -9 -8 -7 -6 -5 -4 -3  -2  -1
 例如：str='helloword'
     print(str[1]) --->  e
     print(str[-1])  --->  d
     print(str[1:3])  --->  el       #含左边不含右边

4.2.列表 list：

 数据用[]来存放，可放任意类型数据，素和元素之间使用逗号隔开，是可变的

 names=['zhao','qian','sun','li']
         修改：list[要修改的元素所在的位置]='修改后的值'        #数字不加引号
         添加：list.insert(位置，'内容')
         移除：list.pop(位置) 或者 del list[位置]         #两种方法所用的括号不同

4.3.元组 tuple：

 与列表类似，用（）存储数据，是不可变的

     例：names=（'zhao','qian','sun','li'）
        age=[1,2,3,4]
        元组不允许修改，但可以组合
        tup=names+age
        print(tup)
     删除元组：del tup            

4.4.字典 dict

 无序的序列，无编号，为获取元素依据标记获取元素  

字典中存放的是键值对   {'key'：'value'}       意思是 {'键'：'键对应的值'}

 例：  

        {'键1'：'键1对应的值'，'键2'：'键2对应的值'}  

键 不允许重复，不可修改，故键是不可变的，键所对应的值可变  

特点：可明确表达数据含义

 例：#获取某个元素的信息
         dict={'姓名'：'张三'，'年龄':'29'}
         name=dict['姓名']
         print（name）     
 或者：
         dict={'姓名'：'张三'，'年龄':'29'}
         print(dict['姓名']) ---> 张三

 元素添加：dict['添加的键']='添加的键所对应的值'   #如果这个值是数字则无需加引号
 元素修改：dict['键']='修改的键所对应的值'  #如果这个值是数字则无需加引号
 删除元素：del dict['要删除的键']
 清空字典：dict.clear（）   #这个括号必须要有，且内容为空
 删除字典：del dict       #删除字典字典后什么也不加

4.5.集合 set

     无序可变序列，集合中不存在重复元素，用{}存放

5.输入功能

输入功能-----用于采集用信息

 value=input('用户提示语')                    #value：是变量名的意思
 print（value）
 print（type（value）） --->   <class 'str'>

  #无论输入的是什么东西 其类型都是  字符串

序列长度计算：len(str/list/tuple)

6.类型转换

 6.1把数据化为整型：
     num=int（value）
 场景：   1. 对小数进行取整
         2. 把字符串格式的数据转化为整型
             要求：value必须满足整数格式
     
 6.2把数据转化为小数：
     float(数据)
     场景：对字符串中的数据进行转化
     要求：只要数据满足数字值格式即可
     
 6.3把数据转化成布尔类型：
     bool
     数值格式的数据：非0即为True
     序列格式的数据：非空序列即为True   #空序列：有壳无数据，空格也是一个数据
         print（‘ ’） --->true
         print（[]）---> false
     空类型的数据None就是False
 6.4把数据转化成字符串
     结果就是在外层加了引号
     str（10） ---> ‘10’
 6.5把数据转化成列表类型：
     要求：数据必须是序列类型的
     结果是生成一个新的列表，列表中的元素是原序列中的元素
     list（‘hello’） ---》['h','e','l','l','o']

7.运算符

7.1算术运算符

➕ 数据之间的加法

也用于字符串中可进行拼接 【要求：只能是字符串与字符串进行拼接】

➖ 数据之间的减法

*数据之间的乘法

可用于字符串中，对字符串内容重复n次

/ 数值数据之间的除法，结果是浮点型

// 两数之间除法向下取整，【最后的结果是小于商但是又最接近于商的整数】

% 两数除法，结果取余数

可用于字符串中，对字符串进行格式化

呈现数据有未知项存在，在未知项的位置使用占位符占位

 name=input('姓名是:')
 A=float(input('语文成绩是:'))
 B=float(input('数学成绩是:'))
 C=int(A)+int(B)
 print('期末考试,%s 的语文成绩是 %.2f，数学成绩是 %.2f，总成绩是 %.2f' % (name,A,B,C))

在字符串内容的后面使用 % 分割 再为对应的未知项填充对应的数据 注意 数据和占位符之间是一一对应的

 %s 填充任意类型数据
 %d 填充整型数据
     %0nd --- 按照n位数格式化数据 不足n位的前面补0       
         '%03d' % 10  -----> '010'
 %f 填充浮点型数据
     %.nf  ------   n表示小数保留的位数

 **    求幂  
 ​
 x**y    求x的y次方

布尔类型的数据于数值类型的数据进行算数运算的时候：True被视为1；False被视为0

7.2赋值运算符

简单的赋值运算符

 = 把等号右边的数据赋值给左边
 a=10
 b=20
     意为：把10赋值给a，20赋值给b；此时a的值为10，b的值为20
 a=b
     意为：把b的值赋值给a，此时a的值就成了20

复合赋值运算：

 +=              /=              **=
 ​
 -=              //=             
 ​
 *=              %=
 ​
 例：y+=x  =====>    y=y+x

7.3比较运算符

>   判断前者是否大于后者
>=  判断前者是否大于等于后者
<   判断前者是否小于后者
<=  判断前者是否小于等于后者
==  判断前者是否等于后者
!=  判断前者是否不等于后者

比较运算符的结果是布尔类型				#  ord('字符')  用来获取字符对应的十进制数据

整个字符串比较的时候 是相同位置的字符进行比较 直到结果被比较出来 *-*-*-

7.4逻辑运算符

 逻辑 与        and
     True  and True  ---> True               
     True  and False ---> False              一假为假
     False and False ---> False
     False and True  ---> False
     
     短路原则：左边为假，右边表达式不参加与运算，如果后面有or会执行or后面的表达式
     
 逻辑 或        or
     False or True  ---> True                
     True  or False ---> True                一真为真
     True  or True  ---> True 
     False or False ---> False
     
     短路原则：左边为真，右边表达式不参加与运算 
     
 逻辑 非        not
     真变假，假变真
     not True = False
     not False = True
 优先级别
     not > and > or
     一般来运算时，优先级别高的执行完，再去执行低的，从左向右执行的

 运算符的优先级
 **，*，/，//，%，+，-，高于比较运算符，逻辑，赋值

例子：

 1、键盘输入一个整数  判断这个数是不是3的倍数
     a = int(input('输入一个整数：'))
     print(a % 3 == 0)
 ​
 2、键盘录入一个年份  判断是不是闰年
     闰年的条件1：能被4整除 但是不能被100整除
     条件2： 能被400整除
     条件1与条件2满足一个即是闰年
     
     print('输入一个年份判断他是否是闰年')
     value = int(input('请输入这个年份：'))
     print((value % 4 == 0 and value % 100 != 0) or value % 400 == 0)
 ​
 3、键盘录入一个数 判断这个数是否能被4整除 并且个位数为2
     num2 = int(input('请输入一个整数:'))
     print(num2 % 4 == 0 and num2 % 10 == 2)

非布尔类型的数据会做一个隐式转换

 有非布尔类型的数据参与逻辑运算的时候  运算的结果不一定是True或者False
 ​
 逻辑与
     一假则假
     左边表达式不成立 右边表达式不参与运算
     
     左边表达式不成立  运算结果 取左边表达式的值
     左边表达式成立  运算结果 取右边表达式的值
 ​
 逻辑或
     一真则真
     左边表达式成立 右边表达式不参与运算
     
     左边表达式成立 运算结果 取左边表达式值的值
     左边表达式不成立 运算结果 取右边表达式的值
     

7.5成员运算符

判断某个元素是否在指定序列中 序列（字典，列表，字符串，元组，集合）

 in  判断某个数据是否在指定的序列中  序列（字典 列表  字符串  元组  集合）
 not in 判断某个数据是否不在指定的序列中

 import string   #import 用于导入内部函数，此处是导入string模块，用来获取键盘字符
     string.ascii_letters        #是键盘上所有的大写字母和小写字母的集合，是字符串
     string.digits           #是键盘上数字的集合（0~9）是字符串
 print（'元素' in 序列）       #判断元素是否在序列中
 ​
 #字典检验的是键是否存在
 ​
 判断结果为True或False

 #输入一个月份判断这个月份是否是31天
 yT={1,3,5,7,8,10,12}
 yue=int(input(''))
 print(yue in yT)

 import random,string            #导入random函数模块和string函数/模块
 back_word=string.ascii_letters+string.digits
 #将英文字符和数字集合起来，此处是形成的是字符串
 key_mini=random.sample(back_word,6)
 print(key_mini)

7.6身份运算符

存储器 ----> 内存结构 --->存储数据的位置 供运算器进行计算的

变量赋值 ,赋予的是数据，本质上赋予的是数据的地址

内存有自己的内部结构，不同区域存储着不同的数据

 栈区
     类似于向上开口的容器  先进后出
     存放运行功能
 ​
 堆区
         存储的是字典，列表，字符串，元组，集合等序列数据 每定义一个新的 就在内存中产生一个     新的空间存放
 ​
 方法区
     常量池
         ———存放字符串类型数据 和 数值的缓存区（-5到257的数据）【面试题】
 ​
         ———特点：获取数据地址时 先检测池中是否有该数据，如果有该数据的话，直接把数据的地址 赋值给变量，如果没有 先在池中开辟空间存储数据，再把空间地址赋值给变量
             字符串 --- 只要内容一样 地址就是一样的
             数值在缓存区内的 数据的地址都是一样的  如果不在 定义一个生成一个新的
     静态池
 ​
 ​
     方法池
 ​
         ———存放的是声明的功能

 A is B   身份运算符，判断A和B 的地址是否相同
 A is not B 判断两数据的地址是否不同

 在python环境下利用DOS命令的判断方法（竖着看）
 a=-5                a=-6                a=256               a=257
 b=-5                b=-6                b=256               b=257
 id(a)==id(b)        id(a)==id(b)        id(a)==id(b)        id(a)==id(b)
 True                False               True                False
 ​
 得出-5到256之间的id位置是一样的

 >>> a = 5
 >>> b = 5
 >>> id(a) == id(b)
 True
 >>> a = 300
 >>> b = 300
 >>> id(a) == id(b)
 False
 >>> s = 'hello'
 >>> s1 = 'hello'
 >>> id(s) == id(s1)
 True
 >>> s = '1234567890wertyuisdfghj'
 >>> s1 = '1234567890wertyuisdfghj'
 >>> id(s) == id(s1)
 True
 >>> l1 = [12, 34, 56]
 >>> l2 = [12, 34, 56]
 >>> id(l1) == id(l2)
 False
 >>> t1 = (1, 2, 3)
 >>> t2 = (1, 2, 3)
 >>> id(t1) == id(t2)
 False
 >>>
 >>> a is b
 False
 >>> t1 is t2
 False
 >>> t1 is not t2
 True
 >>>

7.7位运算符

 直接对二进制数据操作
 二进制数据的形态：原码 反码 补码
 原码：十进制转为二进制数据的格式就是原码
 ​
 正数：原码 反码 补码的格式一样
     数据存储时开辟的空间以字节为单位，1个字节占8位,整数数据占8个字节  就是64位
 ​
 对于二进制数来说 最高位(最左边的那一位)是符号位 0表示正数  1表示负数
 ​
 负数：
     原码：正数对应二进制数据最高位  为1
     反码：负数原码基础上 除最高位，其余为按位取反(0变1  1变0)
     补码：在负数反码的基础上加1
     
 例： 数值10
         0000 1010
     数值-10
          原码：1000 1010
          反码：1111 0101
          补码：1111 0110
 ​
 数据运算形式：补码

 按位与 &
     相同位上的数据有一个数为0 该位上的数据就是0
     8 & -7
     
     0000 1000
     1111 1001
     ---------
     0000 1000  ----(8)
     
 按位或 |
     相同位上的数据有一个数为1 该位上的数据就是1
     8 |  -7
     
     0000 1000
     1111 1001
     ---------
     1111 1001(补码)   看二进制数表示的十进制数据 看的是原码
         反码：1111 1000
         原码：1000 0111   （-7）
         
 按位异或 ^
     相同位上的数据相同 该位上的数据就是0，相同位上的数据不同 该位上的数据就是1【相同为假 不同为真】
     
     
     一个数与相同的数异或两次，结果是其本身
     
     【面试题：使用最少3种方式交换两个变量的值:a=10，b=20
         1.python中：a,b=b,a
         2.借助第三方变量：
             c=a
             a=b
             b=c
         3.使用异或：
             a=a^b       #a=10^20        =20
             b=a^b       #b=10^20^20     =10
             a=a^b       #b=10^20^20     =20
         4.使用距离和：
             a=a+b
             b=a-b
             a=a-b
                                                 】
 按位取反 ~
     表示该位上的数据1变0，0变1
     print(~8)  --->  -9
     ~8
     
     0000 1000
     ~
     ---------
     1111 0111 【补码】 --- 反码：1111 0110 --- 原码：1000 1001  【-9】
 按位左移<<
     【面试题：如何快速计算出2的3次方，1<<3  】
     整体向左移动指定位数，右边空出补0
     
     0000 0001  << 1
     
     0【出去了】  0000 0010  【2】
     0000 0001  << 2
      0000 0100 【4】
 规律:
         数值乘以2^(移动的位数)
         
 按位右移>>
     整体整体向右移动指定位数，左边空出 正数补0，负数补1
     -16>>2
     -16的 原码：1001 0000
     -16的 反码：1110 1111
     -16的 补码：1111 0000
     移动2位：1111 1100
     1111 1100【补码】
         反码：1111 1011
         原码：1000 0100
     规律：
         数值除以2^(移动的位数)

 练习
 10 & -11            ------>    0
     0000 1011
     1111 0100  [补码]
     ----------
     0000 0000      --->0
     
     
 15^-22              ------->   -27
     0000 1111
     1110 1010 [补码]
    -----------
     1110 0101 [补码]--->1110 0100[反码]--->1001 1011[原码]
     
 ~(-22)              
     1001 0110[原码]
     1110 1001[反码]
     1110 1010[补码]
     ~
     0001 0101[补码]
     0001 0101[反码]
     0001 0101[原码]  ------->   22
 ​
 33|-9               ------->   -9
     0010 0001
     1111 0111[补码]
     ----------
     1111 0111[补码]--->1111 0110[反码]--->1000 1001[原码]
 3<<3            
     0000 0011
     0001 1000       ------->   24
 ​
 ​
 48>>3           
     0011 0000
     0000 0110       ------->   6
 ​