python入门语法

学习目标

  • 掌握注释的用法
  • 掌握变量的用法
  • 掌握输入、输出语法
  • 熟练运用运算符

1. 注释的作用

没有注释的代码：


添加注释的代码：


通过用⾃⼰熟悉的语⾔，在程序中对某些代码进行标注说明，这就是注释的作用，能够⼤⼤增强程序的可读性。

2. 注释的分类及语法

注释分为两类：单行注释 和 多行注释。

  • 单行注释

只能注释一行内容，语法如下：

            
# 注释内容
  • 多行注释

可以注释多行内容，一般用在注释一段代码的情况，语法如下：

            
"""
    第一行注释
    第二行注释
    第三行注释
"""
'''
    注释1
    注释2
    注释3
'''
快捷键：ctrl + /

-- 快速练习 --

① 单行注释使用：


# 输出hello world
print('hello world')
print('hello Python') # 输出(简单的说明可以放到一行代码的后面，一般习惯代码后面添加两个空格再书写注释⽂字)

② 多行注释使用：

            
"""
    下面三行都是输出的作用，输出内容分别是：
    hello Python
    hello Java
    hello C#
"""
print('hello Python')
print('hello Java')
print('hello C#')

'''
    下面三行都是输出的作用，输出内容分别是：
    hello Python
    hello Java
    hello C#
'''
print('hello Python')
print('hello Java')
print('hello C#')
注意：解释器不执行任何的注释内容

3. 变量的作用


举例体验：我们去图书馆读书，怎么样快速找到自己想要的书籍呢？是不是管理员提前将书放到固定位置， 并把这个位置进⾏了编号，我们只需要在图书馆中按照这个编号查找指定的位置就能找到想要的书籍。

这个编号其实就是把书籍存放的书架位置起了一个名字，方便后期查找和使用。

程序中，数据都是临时存储在内存中，为了更快速的查找或使用这个数据，通常我们把这个数据在内存中存储之后定义一个名称，这个名称就是变量。


变量就是一个存储数据的的时候当前数据所在的内存地址的名字⽽已

4. 定义变量

            
变量名=值
变量名自定义，要满⾜标识符命名规则

5. 标识符

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：

  • 由数字、字母、下划线组成
  • 不能数字开头
  • 不能使用内置关键字
  • 严格区分大小写

python内置关键字：

False   None   True   and   as   assert   break   class   continue   def   del   elif   else   except   finally   for
from   global   if   import   in   is   lambda   nonlocal   not   or   pass   raise   return   try   while   with   yield

命名习惯：

  • 见名知义
  • 大驼峰：即每个单词首字母都大写，例如： MyName
  • 小驼峰：第二个（含）以后的单词首字母大写，例如： myName
  • 下划线：例如： my_name

'''定义变量    语法：变量名 = 值'''
name = '小白'
age = 22

'''变量名的组成：数字、字母、下划线组成，不允许数字开头、不允许使用保留字，如 if、for、and...'''
a = 1
a_1 = 1
a_ = 1
_1 = 1
1_a = 1   # 不允许数字开头作为变量名

'''由多个单词组成变量名，可以使用下划线连接单词，或者使用驼峰命名，要求见名知意'''
user_name = '小白'    # 单词之间用下划线                          常用于方法名、变量名
userName = '小白'     # 小驼峰：从第二个单词开始，每个单词首字母大写   常用于方法名、变量名
UserName = '小白'     # 大驼峰：每个单词首字母大写                  常用于类名

'''
定义常量    语法：常量名 = 值    注意：常量名要求全大写
常量规定：常量不允许存在二次赋值语句，不允许改变原有值
'''
NAME = '小红'
print(NAME)
NAME = '小兰'     # 不允许改值,虽然不报错，但不符合编程规则，需要程序员自我约束

'''变量赋值'''
b = 1
c = d = e = 2
f, g = 10, 20

'''变量大小写，python区分大小写'''
money = 1000
Money = 9000
mOney = 2000

4. 使用变量


my_name='小白'
print(my_name)
schoolName='XXX实验中学'
print(schoolName)

变量都带有自己的数据类型，初步来了解一下数据类型：

6. 初识数据类型

在 Python ⾥为了应对不同的业务需求，也把数据分为不同的类型。


检测数据类型的方法： type() 
    
a=1
print(type(a)) # <class 'int'> -- 整型

b=1.1
print(type(b)) # <class 'float'> -- 浮点型

c=True
print(type(c)) # <class 'bool'> -- 布尔型

d='12345'
print(type(d)) # <class 'str'> -- 字符串

e=[10,20,30]
print(type(e)) # <class 'list'> -- 列表

f=(10,20,30)
print(type(f)) # <class 'tuple'> -- 元组

h={10,20,30}
print(type(h)) # <class 'set'> -- 集合

g={'name': 'TOM','age': 20}
print(type(g)) # <class 'dict'> -- 字典

7. 基本的print输出语句

作用：程序将内容输出反馈给用户

            
print('hello Python')   # 直接输出字符串

age = 18    # 定义变量
print(age)  # 输出变量

8. 格式化输出

将内容按照指定的格式进行输出。

            
user = '小白'
age = '22'
phone = '18922220000'
print("我叫XXX，今年XXX岁，手机号是XXX")
print("我叫"+user+"，今年"+age+"岁，手机号是"+phone)   # 使用+加号拼接字符串
            
        
            
print("我叫%s" % user)    # %百分号占位符
print("我叫%s，今年%s岁，手机号是%s" % (user, age, phone))  # 有多个占位符时，会根据顺序一一匹配
# print("我叫%s，今年%s岁，手机号是%s" % (user, age))    # 占位符和参数数量要保持一致，多或少了都会报错
# print("我叫%s" % (user, age))
            
        
            
print("我叫{}，今年{}岁，手机号是{}".format(user, age, phone))  # 使用format方法进行格式化
# print("我叫{}，今年{}岁，手机号是{}".format(user, age))  # 参数少于{}占位符个数，会报错
print("我叫{}".format(user, age))  # 参数多于{}占位符个数，不会报错，多出参数不会被使用
print(f"我叫{user}，今年{age}岁，手机号是{phone}")     # 使用f标识字符串进行格式化

%占位符的类型如下：


%.2f 表示小数点后显示的小数位数

9. print结束符

默认情况下，print语句是会换行输出的，如果不想换行输出，则需要更改“结束符”

            
print('中午吃烤鸭！')             # 默认换行输出
print('中午吃烧鸡！', end="\n")   # 结束符\n为换行
print('中午吃炒饭！', end="\t")   # 结束符\t为一个tab键的距离
print('中午不吃饭！', end="~~~")  # 也可以自定义结束字符

10. 基本的input输出语句

在Python中，程序接收⽤户输入的数据的功能即是输入


语法：

            
input("提示信息")

11. input的特点

  • 当程序执行到input，会等待用户输入，输入完成之后才会继续往后执行代码
  • 在编程中，input接收用户输入会后，一般会存储到变量中，方便用户使用
  • 在python中，input会将接收到的用户输入数据，全都当做字符串数据类型进行处理
            
password = input('请输⼊您的密码：')
print(f'您输⼊的密码是{password}')
print(type(password))    # <class 'str'>

12. 运算符的分类

  • 算数运算符
  • 赋值运算符
  • 复合赋值运算符
  • 比较运算符
  • 逻辑运算符
  • 身份运算符
  • 成员运算符

13. 算数运算符

运算符 描述 示例 注意点
+ 加法 1+1输出结果为2 int + str = 报错
str + str = str拼接
- 减法 1-1 输出结果为 0 str - str = 报错
* 乘法 2 * 2 输出结果为 4 str * int = str重复N次
str * str = 报错
/ 除法 10 / 2 输出结果为 5.0 除法的结果都是float类型
分母不能为0
// 整除 9 // 4 输出结果为2 除的结果向下取整
3.88向下取整为3
-8.88向下取整为-9
% 取余 9 % 4 输出结果为 1 余数=被除数-(除数×商)
“商”需要向下取整
** 指数、幂 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
() 小括号 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9
混合运算优先级顺序： () 高于 ** 高于 * / // % 高于 + -

14. 赋值运算符

运算符 描述 示例 注意点
= 赋值 将 = 右侧的结果赋值给等号左侧的变量

  • 单个变量赋值：
            
num = 1
print(num)
  • 多个变量赋值：
            
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)
  • 多变量量赋相同值：
            
a = b = 10
print(a)
print(b)

15. 复合赋值运算符

运算符 描述 示例 注意点
+= 加法赋值运算 c += a 等价于 c = c + a
-= 减法赋值运算 c -= a 等价于 c = c- a
*= 乘法赋值运算 c *= a 等价于 c = c * a
/= 除法赋值运算 c /= a 等价于 c = c / a
//= 整除赋值运算 c //= a 等价于 c = c // a
%= 取余赋值运算 c %= a 等价于 c = c % a
**= 幂赋值运算 c ** = a 等价于 c = c ** a 
            
'''复合赋值案例'''

a = 100
a += 1
print(a)    # 输出101 a = a + 1,最终a = 100 + 1

b = 2
b *= 3
print(b)    # 输出6 b = b * 3,最终b = 2 * 3

c = 10
c //= 1 + 2
print(c)    # 输出3, 先算运算符右侧1 + 2 = 3， c //= 3 , 推导出c = 10 // 3

16. 比较运算符

比较运算符也叫关系运算符， 通常用来作判断，会返回布尔值

运算符 描述 示例 注意点
== 判断相等。如果两个值相等，则条件结果为真(True)，否则条件结果为假(False) 如a=3,b=3，则（a == b) 为 True
!= 不相对 。如果两个值不相等，则条件为真(True)，否则条件结果为假(False) 如a=3,b=3，则（a == b) 为 True
> 运算符左侧的值是否大于右侧的值，如果大于，则条件为真，否则为假 如a=7,b=3，则(a > b) 为 True
< 运算符左侧的值是否小于右侧的值，如果小于，则条件为真，否则为假 如a=7,b=3，则(a < b) 为 False
>= 运算符左侧的值是否大于等于右侧的值，如果大于或等于，则条件为真，否则为假 如a=7,b=3，则(a <= b) 为 False
如a=7,b=3，则(a >= b) 为 True
<= 运算符左侧的值是否小于等于右侧的值，如果小于或等于，则条件为真，否则为假 如a=7,b=3，则(a <= b) 为 False
如a=7,b=3，则(a >= b) 为 True		 
            
a = 7
b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True

17. 逻辑运算符

运算符 逻辑表达式 描述 示例
and x and y 布尔"与"：如果 x 为 False，返回False，否则它返回 y 的值。 True and False，返回False
or x or y 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 True or False，返回True
not not x 布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not True，False 
            
a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True

注意：在python中，所有的0值都为False，除0以外的值都为True值

以下都是0值：

            
int_0 = 0
float_0 = 0.0
str_0 = ""
none_0 = None
bool_0 = False
list_0 = []
tuple_0 = ()
set_0 = set()
dict_0 = {}

也就是说，我们可以直接用数字来做真假运算：

            
a = 0
b = 1
c = 2

# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1

# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
print(a or b) # 1
print(a or c) # 2
print(b or c) # 1

18. 成员运算符

判断某个元素是否存在于某个容器里，返回布尔值

            
str_1 = "中国湖北武汉"
list_1 = [1, 2, 3, 4]
print("湖北" in str_1)  # T
print(1 in list_1)  # T
print("中国武汉" in str_1)  # F
print(1 in list_1 and "湖北" in str_1)  # T
print(1 in list_1 or "湖北" in str_1)  # T

print("湖北" not in str_1)  # F
print(1 not in list_1)  # F
print("中国武汉" not in str_1)  # T
print(1 not in list_1 and "湖北" not in str_1)  # F
print(1 not in list_1 or "湖北" not in str_1)  # F

19. 身份运算符

判断两个变量是否引用于同一个对象（内存中共用同一个空间）

            
x = [1, 2, 3]
y = [1, 2, 3]
z = x
print(z is x)       # z和x是否引用于同一个对象 T
print(y is x)       # F
print(z is not x)   # F
print(y is not x)   # T

总结：

  • 顺序：算数运算符--->成员--->身份运算符--->比较运算符--->逻辑运算符--->赋值运算符
  • 同级运算符，遵守从左往右规则
  • 可以使用()小括号改变优先级