python基础语法学习

最新推荐文章于 2024-07-06 12:03:33 发布

凌小皮_177

最新推荐文章于 2024-07-06 12:03:33 发布

阅读量190

点赞数

分类专栏： python 文章标签： python 编程语言

本文链接：https://blog.csdn.net/qq_51212018/article/details/113757996

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。 Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

一、基础语法

1.标识符

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

2.注释

Python中单行注释以 # 开头，实例如下：

# 第一个注释
print ("Hello, Python!") # 第二个注释

多行注释可以用多个 # 号，还有 ‘’’ 和 “”"：

# 第一个注释
# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

二、数据类型

1.标准数据类型

Python3 中有六个标准的数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

2.Number

Python3 支持 int、float、bool、complex（复数）。（在Python 3里，只有一种整数类型 int，表示为长整型。）
代码如下（示例）：

 a, b, c, d = 20, 5.5, True, 4+3j
 print(type(a), type(b), type(c), type(d))
 #<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

Python 数字类型转换：

int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

注意：

1、Python可以同时为多个变量赋值，如a, b = 1, 2。

2、一个变量可以通过赋值指向不同类型的对象。

3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

4、在混合计算时，Python会把整型转换成为浮点数。

3.String（字符串）

字符串的定义
可以使用引号( ’ 或 " )来创建字符串，示例如下：

str1 = 'Hello World!'
str2 = "Hello Python!"

访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

#变量[头下标:尾下标]
str1 = 'Hello World!'
str2 = "Hello Python!"
print(str1[0]) #H
print(str2[1:5) #ello

字符串运算符
+：字符串的连接
*：重复输出字符串
[]：通过索引获取字符
[:] : 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
in: 成员运算符 - 如果字符串中包含给定的字符返回 True
not in: 成员运算符 - 如果字符串中不包含给定的字符返回 True
%: 格式字符串
字符串格式化
1. %c ：格式化字符及其ASCII码
2. %s ：格式化字符串
3. %d ：格式化整数
4. %u ：格式化无符号整型
5. %o ：格式化无符号八进制数
6. %x ：格式化无符号十六进制数
7. %X：格式化无符号十六进制数（大写）
8. %f ：格式化浮点数字，可指定小数点后的精度
9. %e ：用科学计数法格式化浮点数
10. %E ：作用同%e，用科学计数法格式化浮点数
11. %g ：%f和%e的简写
12. %G ：%f 和 %E 的简写
13. %p ：用十六进制数格式化变量的地址

示例代码：

print ("我叫 %s 今年 %d 岁!" % ('张三', 18)) #我叫 张三 今年 18 岁!

4.列表

列表创建
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['hello', 'World', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

访问列表中的值
与字符串的索引一样，列表索引从 0 开始,实例：

 list = ['hello', 'World', 1997, 2000]
 print( list[0] ) #hello
 print( list[1] ) #World
 print( list[2] ) #1997
 print(	list[-1]) #2000
 print( list[-2] ) #1997
 # 从第二位开始（包含）截取到倒数第一位（不包含）
print ("list[1:-2]: ", list[1:-1]) #World 1997

删除列表中的元素

 list = ['hello', 'World', 1997, 2000]
 print ("原始列表 : ", list) #['hello', 'World', 1997, 2000]
 del list[2]
 print ("删除第三个元素 : ", list) #['hello', 'World',2000]

列表函数&方法
1，len(list)
列表元素个数
2，max(list)
返回列表元素最大值
3，min(list)
返回列表元素最小值
4，list(seq)
将元组转换为列表
5，list.append(obj)
在列表末尾添加新的对象
6，list.count(obj)
统计某个元素在列表中出现的次数
7，list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
8，list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
9，list.insert(index, obj)
将对象插入列表
10，list.remove(obj)
移除列表中某个值的第一个匹配项
11， list.sort( key=None, reverse=False)
对原列表进行排序
12，list.clear()
清空列表
13，list.copy()
复制列表

5.元组

元组与列表类似，不同之处在于元组的元素不能修改。

创建元组

	tup1 = () #空元组
	tup2 = (30,) #元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

访问元组

tup1 = ('hello', 'world', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

修改元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

#以下修改元组元素操作是非法的。
#tup1[0] = 100

#创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

删除元组

tup = ('hello', 'world', 1997, 2000)

print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

元组内置函数

tuple(iterable)
将可迭代系列转换为元组。
len(tuple)
计算元组元素个数。
max(tuple)
返回元组中元素最大值。
min(tuple)
返回元组中元素最小值。

元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。

6.字典

字典是另一种可变容器模型，且可存储任意类型对象。

创建字典

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

访问字典中的值

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

修改字典

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

dict['Age'] = 8               # 更新 Age

删除字典元素

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

del dict['Name']  # 删除键 'Name'
dict.clear()      # 清空字典
del dict          # 删除字典

字典内置函数&方法

len(dict)
计算字典元素个数，即键的总数。
str(dict)
输出字典，以可打印的字符串表示。
type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。
radiansdict.clear()
删除字典内所有元素
radiansdict.copy()
返回一个字典的浅复制
radiansdict.get(key, default=None)
返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict
如果键在字典dict里返回true，否则返回false

字典键的特性
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住.
- 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

7.集合

集合（set）是一个无序的不重复元素序列。

创建集合
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) #集合具有去重功能

添加元素
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x )

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

移除元素
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.remove( x )

还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

计算集合元素个数
计算集合 s 元素个数。

len(s)

清空集合
清空集合s。

s.clear()

集合内置方法
- add() 为集合添加元素
- clear() 清空集合
- discard() 删除集合中指定的元素
- pop() 随机移除元素
- remove() 移除指定元素
- update() 给集合添加元素

三、语句结构

1.条件控制

if语句的一般形式如下所示：

if condition_1:
   执行语句1
elif condition_2:
   执行语句2
else:
   执行语句3

if嵌套
在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

if 表达式1:
    语句1
    if 表达式2:
        语句2
    elif 表达式3:
        语句3
    else:
        语句4
elif 表达式4:
    语句5
else:
    语句6

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句。

2.循环语句

while循环语句格式如下：
```
while 判断条件：
	 执行语句
```
需要注意冒号和缩进。另外，在 Python 中没有 do…while 循环。
while 循环使用 else 语句
在 while … else 在条件语句为 false 时执行 else 的语句块。
语法格式如下：

'''while 条件1:
    语句1
else:
    语句2'''
    count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

for语句
for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for循环的一般格式如下：

'''for item in 序列:
   语句1
else:
   语句2''
   list = ['hello','world',1997,2000]
   for item in list:
   	print(item)

range()函数
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

for i in range(5):
   print(i)	# 0 1 2 3 4
for i in range(5,9) :
   print(i)  #5,6,7,8

四、输入输出

1.输出

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

str()：函数返回一个用户易读的表达形式。
repr()：产生一个解释器易读的表达形式。

#输出方式一
print('hello','world')	#hello	world
#输出方式二
print('{0} and {1}'.format('hello','world') 	hello and world
#输出方式三
age=10
print(f'我的年龄为{age}岁')	#我的年龄为10岁
#输出小数1.234
print('x={:.3f}'.format(1.234)	#1.234

2.输入

input可以接收一个表达式作为输入，并将运算结果返回。

str = input("请输入：");
print ("你输入的内容是: ", str)

五、函数

1.函数的定义

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的return 相当于返回 None。
代码示例：

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

2.参数传递

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

传不可变对象实例

def change(a):
   print(id(a))   # 指向的是同一个对象
   a=10
   print(id(a))   # 一个新对象

a=1
change(a)
'''输出结果
140708062561968
140708062561968
140708062562256'''

从结果可以看出：形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

传可变对象实例
可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

# 可写函数说明
def change( list ):
   list.append([1,2,3,4])
   print ("改变后的值: ", list)
   return
 
# 调用changeme函数
mylist = [10,20,30]
change( mylist )
print ("改变前的值: ", mylist)
'''输出结果：
改变后的值:  [10, 20, 30, [1, 2, 3, 4]]
改变前的值:  [10, 20, 30, [1, 2, 3, 4]]

3.匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
实例：

sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

六、File(文件) 方法

1.open()方法

open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')
#完整格式为
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode常用参数值有：

w：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+：打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
r+：打开一个文件用于读写。文件指针将会放在文件的开头。

2.file对象

file.close()
关闭文件。关闭后文件不能再进行读写操作。
file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])
读取整行，包括 “\n” 字符。
file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.write(str)
将字符串写入文件，返回的是写入的字符长度。
file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

七、模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

1.import语句

import sys
 
print('命令行参数如下:')
for i in sys.argv:
   print(i)
 
print('\n\nPython 路径为：', sys.path, '\n')

import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
sys.argv 是一个包含命令行参数的列表。
sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

2.from…import语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

3.from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

八、面向对象

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.类定义

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

class 类名(object):
	语句

2.类的属性与方法

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。self.__private_methods。
实例：

class People(object):
	__sex = '男'	#私有变量
	work = '程序猿'	#公开变量
    def __init__(self, name, age):
        self.name = name      # public
        self.age = age   # private
 
    def who(self):
        print('name  : ', self.name)
        print('sex : ', self.__sex)
        print('work : ', self.work)
        print('age : ', self.age)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        #调用私有方法
        self.__foo()
p = People('张三',28)
p.who()	
p.foo()
p.__foo()
'''运行结果：
name  :  张三
sex :  男
work :  程序猿
age :  28
这是公共方法
这是私有方法
报错
'''

3.构造方法

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self): #self代表类的实例，而非类
    self.data = []

4.类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('张三',10,30)
p.speak()

5.继承

派生类的定义如下所示:

#格式
class DerivedClassName(BaseClassName):

#实例
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #重写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()

6.方法重写

class Instrument(object):

    def make_sound(self):
        pass

class Erhu(Instrument):

    def make_sound(self):
        print('二胡在演奏...')

class Violin(Instrument):

    def make_sound(self):
        print('小提琴在演奏...')

class Guitar(Instrument):

    def make_sound(self):
        print('吉他在演奏...')

def play(instrument):
    instrument.make_sound()

if __name__ == '__main__':
    play(Erhu())
    play(Violin())
    play(Guitar())

凌小皮_177

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础语法学习

简介Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录简介一、基础语法1.标识符2.注释二、数据类型1.标准数据类型2.Number3.String（字符串）4.列表4.元组5.字典6.集合一、基础语法1.标识符第一个字符必须是字母表中字母或下划线 _ 。标
复制链接

扫一扫