【Python】快速入门Python一天学完基础语法

Python 语法基础

前言

这几天由于实际的工作需求，技术栈急转弯，要从日常写得最多的Java转到Python。

可是Python之前我一直只会一点皮毛，只写过一点Demo，且太久没动过了，于是，就要寻找合适的教程快速将语言基础过一遍，然后马上投入实战。

前提

• 由于这是我实际工作过程中遇到的python学习需求，默认读者有一定的编程语言基础。
• 开发环境我很早之前就配好了。若要跟练的话，默认读者本地已经配好python环境。
• 本文基于Python 3.9的基础语法，不同版本Python可能略有不同（主要是2.x 与 3.x 的差别）。
• 本文一次性记录了整个基础语法的学习过程，属于长文，初学的读者需要花一点时间阅读，建议先收藏，后续分片慢慢阅读。

学习目标

• Python 快速入门
• 了解基础重点即可，快速入门语法，至于深入，以后再研究

好的，那么接下来，准备一个空Python项目，我们开始！

1. HelloWorld

程序猿的第一句代码都是HelloWorld。

创建一个 hello_world.py 文件，键入：

print("hello world!")

控制台打印经典的hello world。

pycharm 执行。如示例图所示：

在这个过程中，我们也熟悉了Pycharm执行Python程序的流程。

恭喜！咱们已经完成了第一句Python！接下来，就是对语法的快速入门学习了。

2. 变量与数据类型

2.1 变量

Python 的 变量定义很简单：<变量名> = <值>

命名规范：变量名小写，驼峰改下划线：

例如：

# 变量
name = 'spider man'
age = 18
money = 100.1
is_single = True
print('name=', name,'age=', age,'is singl:', is_single)
print('money=', money,'')

由这个例子我们也发现：python中一般的数据类型不需要像Java、C一样显式声明数据类型。

经典的控制台输入
python 中，控制台输入使用input()，类似于 Java.lang 包的东西，属于是python初始内置的函数。

我们拿个示例演示一下：

name = input('what is your name?')
age = input('what is your age?')
print('your name is '+name, 'and your age is'+age)

经过以上两个例子，我们已经了解了python中变量的定义，以及控制台接收输入的方式。另外，print 方法的两种打印：逗号以及加号拼接均有演示。

2.2 数据类型

基本的数据类型与其它高级语言类似，需要注意的是boolean类型的值在python中的表示是大写开头的True或False。

以下介绍相对重点的String、基本类型转换、拆包，以及常见包装类型：元组与字典。

2.2.1 String 字符串类型

定义字符串
首先，Python 中，字符串的定义可以是：单引号、双引号和三引号。其中不同引号的用法根据实际使用场景及个人习惯而异。

例如：

# 定义 字符串
name1 = " '<NAME>' "
print(name1)

name2 = '"<NAME>'
print(name2)

name3 = '''
	<NAME>
	<haha>
'''
print(name3)

截取字符串
Python 中，字符串的下标也是由0开始的。但值得注意的是，下标-1表示倒数第一个元素。而且，Python 提供了内置的截取字符串方法，<变量名>[index_start : index_end]

具体看如下示例：

# String 类型的index
demo_string = "Hello"

# 起始坐标：0
demo1 = demo_string[0]
print(demo1)

# 倒数第1个坐标
demo2 = demo_string[-1]
print(demo2)

# 复制整串
demo_hole = demo_string[:]
print(demo_hole)

# 截取字符串
demo_part1 = demo_string[:3]
demo_part2 = demo_string[3:]
print(demo_part1)
print(demo_part2)

格式化字符串

# 格式化字符串
demo_f = "first"
demo_s = "second"

demo_formart = f'"{demo_f}" and "[{demo_s}]"'
print(demo_formart)

字符串常用方法
与Java String一样，String类型提供了一些常用的基本方法。这里我们直接通过例子学习常见方法：

# 演示常用方法
lenght_demo = "123456 ak Vs 789 m4"
print(len(lenght_demo))
up_demo = lenght_demo.upper()
print(up_demo)
title_demo = lenght_demo.title()
print(title_demo)
lower_demo = lenght_demo.lower()
print(lower_demo)
ak_index = lenght_demo.find('ak')
print(ak_index)
is_in = 'S' in lenght_demo
print(is_in)
print(lenght_demo.replace('Vs','and'))

2.2.2 基本类型转换

基本类型转换可以使用<类型名>(变量名)的方式进行转换；
查看类型可以使用 type()函数，示例如下：

# 输入年份，接收到的默认为str类型
year = input('Enter a year: ')
now_year = 2024
# 查看类型
print(type(year))
print(type(now_year))
# 转换
diff = now_year - int(year)
print(diff)

2.2.2 元组

元组是一种特殊的数据类型。元组的知识点在考试考得比较多，也是一个重点

元组有以下特点：

• 不可修改，类似于Java 的 final list
• 只有一个元素时，括号结尾要加上逗号，避免歧义
• 任意无符号的对象，以逗号隔开，默认为元组

示例

# 创建元组的方式 ()
list01 = (0, 1, 2)
list03 = [0, 1, 2]
list02 = tuple(list03)

# 默认为元组
item1, item2, item3 = 'a', 'b', 5

# 遍历元组的方式
for item in list01:
    print(item)

# 倒序遍历
for i in range(len(list02) - 1, -1, -1):
    print(list02[i])

# 正序遍历
for i in range(0, len(list02), 1):
    print(list02[i])

元组常见操作

• len(tuple)：计算元组元素个数。
• max(tuple)：返回元组中元素最大值。
• min(tuple)：返回元组中元素最小值。
• tuple(seq)：将列表转换为元组。
• del <tup_name>: 删除整个元组。
• 组合元组：链接组合，直接使用+号链接若干个元组。

举例：

# 定义元组
t1 = (1, 2, '3')
t2 = (1, 2, '3')
t3 = t1 + t2
t4 = (1, 2, 3)

list5 = ['a', 'b', 'c']

print(t3)

print(len(t3))
# 元组中类型统一才能使用max函数
print(max(t4))

t5 = tuple(list5)
print(t5[-1])
print(min(t5))

del t3

# 已经删除，以下执行会报错
# print(t3)

遍历元组
在上面的例子中，我们已经演示了如何遍历元组。元组虽然不可变，但遍历元组的方式与遍历列表的方式是非常类似的。

2.2.3 字典

字典在Python中类似于一个特殊的HashMap，这个HashMap中的元素以键值对的形式表示。其中，键一般都是不可变类型，可哈希。一般我们用str类型居多。特别地，字典中的key必须唯一。

以下是代码示例：

# 创建字典
user = {
    "username": 'Jack',
    "password": 123456,
    "is_admin": False
}

print(user)

# 设置字典 key-value 值
user["score"] = 98
print(user.get("score"))
# 没有设置,拿不到 none
print(user.get("code"))
# 拿的时候给默认值
print(user.get("money", "very much"))
# pop 字典某key
user.pop("username")
print(user)
# 更新字典某key的值
user["password"] = "<PASSWORD>"
print(user["password"])

2.2.4 拆包

拆包是Python中的一个重要特性，可用于元组、列表等快速取值，并将其值使用。

# 定义元组、列表
t1 = (1, 2, '6')
list1 = [1, 5, 7]

# 拆包
x, y, z = t1
l, m, n = list1

print(
    f'l = {x}, m = {y}, type(z) = {type(z)}, n = {z}'
)

print(
    f'l = {l}, m = {m}, n = {n}'
)

# 其过程等同于
x = t1[0]
y = t1[1]

2.3 运算

现在的高级语言，基本运算几乎都大差不差，这里只提一些python中不太一样的地方。

2.3.1 双除号/双乘号

双除号截断除法
双除号除法表示截断除法，返回一个整数。

# 双除法返回整数
print(4//3)

双乘号次方
双乘号表示次方

# 双乘号表示次方
print(10**3)

注意，次方的运算在运算表达式中，优先级是最高的，例如：

# 先计算次方，这个例子的结果应该为49.
print(1+2 * 3 * 2**3)

2.3.2 常见运算函数举例

python中也有很多内置的数学函数，我们直接举例学习：

import math

# 内置函数四舍五入
print(round(2.9))

# 内置函数绝对值
print(abs(-96))

# math包下的函数向下取整
print(math.floor(2.6))

2.3.3 布尔运算

布尔运算的一些基本与或非，和我们的java也不尽相同，python中与或非用and、or、not关键字表示。当然也很简单，直接举例：

# boolean 运算
is_ok = True
is_not_ok = False

print(is_ok and is_not_ok)
print(not is_ok)
print(is_ok or is_not_ok)
print(is_ok or not is_not_ok)

3. 控制流程

3.1 if-else 语句

Python 的 if-else 语句语法与 Java等类C语言大有不同。当然也不难学，我们直接拿例子举例，大家看看就懂了：

# if else 语句学习
user_input = input('please inter 1 or 2 to continue')
input_value = int(user_input)

# 单 if
if input_value == 1:
    print('hello world!')

# if-else
if input_value == 1:
    print('hello world!')
else:
    print('hello python!')
print('this is a demo')

if input_value == 1:
    print('hello world!')
elif input_value == 2:
    print('hello jemmy')
else:
    print('have a good time!')

3.2 while 循环

有了以上 python if-else 语句的基础，我们就进一步熟悉了python的语法风格，因此 while 循环也更易于理解。我们直接上例子：

# while 循环 demo
i = 0

while i <= 5:
    print("*" * i)
    i += 1

print("done.")

但值得注意的是，在python中，while 也可以接上 else 来进行兜底操作，如：

# while demo

init_times = 0
times = 3
target = 5

while init_times < times:
    init_times += 1
    guss = int(input('Please enter your guss, tips : less than 10'))
    if guss == target:
        print('You win!')
        break
else:
    print('You lose!')

另外需要注意的是，python中，由于少了类C语言的括号{}包裹代码块，实际编写时，要十分注意缩进！例如，此处 if 的break，若是少了缩进，就会被解释器认为这个break是在while循环体一级的，这样就会导致执行一次就break了！

3.3 for 循环

Python中的for循环，有点类似Java的增强for循环。有趣的是，Python中的for还能直接遍历字符串：

# for 遍历字符串
for item in 'Python':
    print(item)

# for 遍历范围函数
for item in range(10):
    print(item)
    
for item in range(3, 6):
    print(item)

for item in range(2, 5, 2):
    print(item)

# for 遍历数组
for item in ['Tom', 'John', 'Smith']:
    print(item)

Python 中的for，可以遍历相当大的带范围的对象。

嵌套for循环
直接举例：

# 嵌套遍历
array_demo = [5, 2, 5, 2, 2]
for i in array_demo:
    temp = ''
    for j in range(i):
        temp += str('x')
    print(temp)

4. 方法/函数

在前面的小节中，我们已经了解过Python的语法风格，与Java、C等不同的是，结尾不需要带分号，代码块用缩进代替大括号。

因此，在Python中，方法的定义也是这种风格的语法，如以下示例：

# 定义方法
def my_method():
    print('Hello World!')


my_method()

注意，在这个简单的方法练习中，我们需要注意的是python代码规范，例如：方法下，要空2行。结束行后要回车加一行空行。否则会被pycharm告警。

除此之外，Python中的方法还有和Java等语言不同的地方，例如在调用方法的同时可以打乱参数顺序，加上参数名来指定对应的参数，从而提高可读性，并且不需要过多关心各参数顺序。

# 多个参数方法
def multiple_parameters(a, b):
    print(f'a = {a}, b = {b}')
    return a + b


print(multiple_parameters(1, 2))
# 指定参数
print(multiple_parameters(b=9, a=1))

5. 异常处理

Python中的异常处理也和Java等不同。使用的是try - except关键字。

举例：

# 创造异常 ：ZeroDivisionError
# print(1/0)

# 创造异常 TypeError
# a = input("Enter a number: ")
# print(a / 2)

# try-except 语句
b = int(input("Enter a number: "))
try:
    print(2 / b)
except ZeroDivisionError:
    print("ZeroDivisionError, division by zero")

# 多个 exception
c = input("Enter a number: ")
try:
    print(2 / c)
except ZeroDivisionError:
    print("ZeroDivisionError, division by zero")
except TypeError:
    print("TypeError, invalid number")
    

6. 面向对象

Python 也支持面向对像。若读者也有一定的面向对象基础，那么Python中的类定义、继承等方法，均与其它面向对象编程语言类似，仅记住语法区别即可。

6.1 类与对象

我们直接创建一个User类，来进行示例：

# 类定义
class User:

    # 构造函数，self类似于 Java的 this
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    # 类方法
    def full_name(self):
        return f"{self.first_name} {self.last_name}"


# 创建对象
user = User("Sharry","Xian")
print(user.full_name())
print(user)

上述例子列举了user类的创建。与Java等语言一样，首先是类名大写，然后需要有构造方法，不写这个构造方法会默认使用默认的隐藏的构造方法。方法里的self参数类似于this，创建对象及调用类的方法时不需要显式传入self。

6.2 继承

Python 中的继承通过括号进行。特别地，Python支持多继承。
先上例子：

# 演示继承以及方法的重写
class Animal:
    def eat(self):
        print("Eating...")


# pass 表示不做操作，直接通过。甚至说，从语法上，空的类也可以pass掉
class Dog(Animal):
    pass

class Cat(Animal):
    # 直接定义同名方法重写
    def eat(self):
        print("hello ")

    def bark(self):
        print("bark ")


# python 支持多继承
class Monkey(Dog, Cat):
    pass


dog1 = Dog()
dog1.eat()

cat1 = Cat()
cat1.eat()

monkey1 = Monkey()
# 执行的是继承树最近的一个重写方法，继承树同级时，调用先继承的方法
monkey1.eat()
monkey1.bark()

从上述例子中，我们了解了Python中的继承机制。主要是语法不同，用小括号加类名进行继承，其次是可以多继承。

Python 3.9 中，重写父类的方法只需要直接将同名方法重新写一遍，不需要像Java中一样添加注解标识重写。但有一个需要补充的，若需要在子类调用父类的方法，使用super()方法。

7. 补充与总结

7.1 列表常用方法

Python 中，列表常用的方法与Java等语言提供的一些list方法一样，都有插入、清除、取出等操作。直接上示例：

name = ['Jack', 'John', 'Smith', 'Sharry']

# 数组常用方法
name.remove('Jack')
print(name)

name.reverse()
print(name)

name.append('Rebecca')
print(name)

name.insert(3,'Jim')
print(name)

name.clear()
print(name)

不仅仅是数组，python中许多内置API的使用，均可翻阅官方文档：
python-官方文档

7.2 元组与列表

• 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
• 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
• 应用： 变量交换的本质就是创建元组：x, y = （y, x ）

7.3 import

import 类似于 Java 的导包。Python 中的 import 有如下几种方式:

从特定的包/模块的py文件中 import 特定的方法

# 从一个模块的某py中，import特定的方法，多个方法用逗号隔开

from import_demo.method_demo import method_demo_hello, say

# 这种方式import的方法可以直接调用
method_demo_hello()

say()

import 文件夹对应的模块

import import_demo.method_demo

import_demo.method_demo.say()

import 模块

import random

for i in range(3):
    print(random.randint(10, 20))

7.4 魔术方法

以双下划线开头、结尾命名的方法在Python中被称为魔术方法。
在本文的一些例子中，我们已经使用过魔术方法，例如__init__()

魔术方法在python中也有很广泛的用途，具体常用的魔术方法，篇幅有限，请参阅其它参考文章。

7.5 总结

通过本文，我们一文学习了Python基本语法。此处总结与Java等语言的语法上的不同之处：

• 主要语法区别：python用缩进代表代码块，并省略了结束的;
• import 方式：支持多种 import 方式，主要是import 和 from xxx import xxx，灵活
• else-if 关键字，python有缩写 elif；try-catch 关键字在python中为except
• 元组、字典，两个特殊数据类型，拆包特性
• 方法定义语法格式不同
• 面向对象支持多继承，语法格式有所不同

但总的来说，python 语法相对简洁，库很多，也支持跨平台。飞速发展的信息时代，多学点总有好处。希望通过本文，读者能掌握Python语法基础，为日后多语言项目异构、同一场景多种技术解决方案打下基础。

Respect！

参考资料

• bilibili-油管Python高分教程
• python-官方文档
• 博客园-元组优秀参考博文