代码组织，缩进，注释，标识符，print
可能里面有一些基本概念初学者没有怎么接触过，可以先忽略， 比如类、私有属性、构造函数等。
1 基本元素
1.1 代码组织
java或者其他很多的计算机语言一般是通过{}来标识代码块，而对于python而言，是使用的缩进来组织代码块，通过4个空格来缩进代码。如以下
if true:
print(1)
else:
print(2)
1.2 注释
单行注释与多行注释
# 单行注释
'''
第一行
多行注释
第二行
'''
在我们使用的vscode或者pycharm中，我们一般可以通过ctrl /来实现代码的注释，生成的为单行注释
1.3 \行连接符
对于跨越很多行的字符串，我们可以通过\符号来换行，增强代码的可读性，不然需要你疯狂移动的横向滚动条
s = "i" \
"love" \
"study"
1.4 标识符
标识符主要是用于变量、函数、类和模块等的明明。pytho中，标识符可以由数字、字母、下划线组成，所有的标识符不能以数字开头。
一般情况下，我们认为采用下划线开始的标识符具有特殊的意义，如下
_单下划线开头：不能直接访问类属性，需要通过接口进行访问，不能采用from xxx import *的方式__双下划线开头：类的私有成员__xx__双下划线开头结尾的：特殊方法专用的标志，如__init__()代表构造函数
标识符一般有特定的规则：
- 区分大小写：
xxx与XxX是不一样的 - 第一个字符必须是字母、下划线
- 以双下划线开头和结尾的名称通常具有特殊的含义，尽量避免这种写法
标识符的命名规范
| 类型 | 规则 | 例子 |
|---|---|---|
| 模块和包名 | 全小写字母，尽量简单，多个单词间用下划线分割 | math, os, sys, my_module |
| 函数名 | 全小写字母，多个单词之间用下划线分割 | phone, my_age |
| 类名 | 首字母大写，采用驼峰原则，多个单词时，每个单词第一个字母大写，其余字母小写 | MyInfo, MyClass |
| 常量名 | 全大写字母，多个单词使用下划线隔开 | SPEED，PI，MAX_AGE |
同时我们应该避免我们的变量与保留字重合，保留字是指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’]
1.5 print输出
print("yes")
print("a", end='') # 不换行打印
print("a", end='##') # 打印以 ## 结尾
在控制台打印yes。也可以打印多行文本
#输出多行字符串
print(''' 静夜思
李白
床前明月光, 疑是地上霜。
举头望明月, 低头思故乡。
''')
打印多个字符串
print("a", "b", "c") # abc
格式化输出
在字符串内部，%s 表示用字符串替换，%d 表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。常见的占位符如
| 占位符 | 类型 | 示例 |
|---|---|---|
| %d | 整数 | a = 10 b = 5 print(“%d-%d=%d” %(a,b,(a+b))) |
| %f | 浮点数 | a=3.5 print(“这是小数%0.1f” %a) |
| %s | 字符串 | name=“admin” print(“my name is %s” %name) |
| %x | 十六进制整数 | a=20 print(“%x” %a) |
还有一种字符串的格式化方法：format
a = 1
b = 2
print(str(a) + "+" + str(b) + "=" + str(a+b))
print(a, "+", str(b), "=", str(a+b))
print("{}+{}={}".format(a,b, a+b))
1.6 input
使用input获取键盘的输入
a = input("请输入")
print(a) # 将会打印你在键盘上输入的值
2 变量与赋值
2.1 变量的使用
python不需要在变量前声明其类型，但是必须为变量赋初值
error_param # 未经初始化赋值是错误的
a = 123 # 声明一个整数类型
b = "123" # 声明一个字符串类型
c = 12.3 # 声明一个浮点型类型
变量在计算机内存中一般是这么存储的，如下图
注：『纯理解层面』，计算机内存一般会划分为栈内存和堆内存，一般在栈内存内会存放变量的地址，我们在访问变量的时候，其实是变量通过地址引用了『对象』。需要注意的是，变量位于栈内存，对象位于堆内存。
id()： 我们可以使用id()来获取变量的物理地址，从而判断两个变量是否指向同一个对象
a = 1
b = 2
c = a
id(a) == id(b) # false
id(a) == id(c) # true
2.2 变量使用的扩充
变量链式赋值
a,b = 10, 20 # 变量的链式赋值
print(a, b) # 10 20
删除变量
a = 111
print(a) # 111
del a
print(a) # error, a is not defined
3 数据类型
3.1 分类
- 基本数据类型：
Number, Boolean, String - 高级数据类型：
Tuple, List, Set, Dict
3.2 运算符
-
算数运算符
+, -, *, /
//整数除法，去掉小数点7 // 2 = 3
%取余7%4=3
**幂2**3 = 8 -
关系运算符
== # 等于
!= # 不等于
< # 小于
<= # 小于等于
> # 大于
>= # 大于等于
- 逻辑运算符
and # true and true = true
or # true or false = false
not # not true = false
- 赋值运算符
= # 等于
+= # c = c + a 等价于 c+= a 以下运输符以此类推
-=
*=
/=
**=
//=
- 位远算符
& # 按位与
| # 按位或
^ # 按位异或
~ # 按位取反
<< # 左移位
>> # 右移位
a = 6 # 0000 0110
b = 3 # 0000 0011
a&b # 0000 0010 = 2
# | ^ ~ 依次类推
a<<2 # 0001 1000 = 24 左移2位，后补0
a>>2 # 0000 0001 = 1 右移2位 前补0
- 成员运算符
in, not in
1 in [1,2,3,4] # true
1 not in [1,2,3,4] # false
- 身份运算符
is, is not：判两个对象是或者不是引用的同一个对象
a = 1
b = 2
c = 1
a is c # true 同 id(a) == id(c)
运算的优先级
ps: 其实不怎么用记这个优先级,一般情况下我们可以使用括号来强制制定优先级，如小学数学里面学过的(a-+b)*c
**
~ + -
* / % //
+ -
>> <<
&
^ |
<= >=
== !=
= %= /= //= += -= *= **=
is is not
in not in
not or and
3.3 字符串
a = "a" # 可以使用单引号 也可以使用双引号
b = 'b'
# 长字符串
s='''
I
Love
Python
'''
c ="\", \n" # 转义字符
#测试转义字符
a = 'I\nLove\nPython' #\n 换行符
print(a)
b="aa\tbb\tcc"#\t 制表符
print(b)
c='Let\'s go'#单引号中同时包含单引号使用\'进行转义
print(c)
字符串的切片：
s='abcdef'
print(s[:]) #start 和 end 都省略，截取整个字符串 输出结果：abcdef
print(s[2:]) #end 省略，从 start 开始到结束 输出结果:cdef
print(s[:2]) #start 省略 从 0 开始到 end-1 输出结果:ab
print(s[2:4]) #从 start 开始到 end-1 输出结果:cd
print(s[1:5:2]) #从 start 提取到 end-1，步长是 step 输出结果:bd
格式化 format
format 方法还可以控制值的左、中、右对齐， “^”、“<”、“>”分别是居中、左对齐、右对齐，后面带宽度。“:”号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充。
s="姓名:{0},年龄:{1},薪资:{2}"
print(s.format('张三',23,13000))
print("{:*>8}".format("245"))
print("{:#^20}".format("Python"))
a = "我是{}，我的存款有{:.2f}"
print(a.format("张三",3888.234342))
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | 3.14 | 带符号保留小数点后两位 |
| 2.78121 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零（填充左边，宽度为2） |
| 5 | {:x<4d} | 5xxxx | 数字补x（填充右边边，宽度为4） |
| 10 | {:x<4d} | 10xx | 数字补x（填充右边边，宽度为4） |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00E+09 | 指数记法 |
| 13 | {:10d} | 13 | 右对齐（默认，宽度为10） |
| 13 | {:<10d} | 13 | 左对齐（宽度为10） |
| 13 | {:^10d} | 13 | 中间对齐（宽度为10） |
常用方法
a = "hello, one"
print(a.find("o")) # o首次出现的位置 没有找到则返回-1
print(a.index("o")) # o首次出现的位置 没有找到则会报错
# print(a.index("a")) # a首次出现的位置 没有找到则会报错
print(a.count("o")) # 统计a中出现o的次数
print(a.replace("o", "0")) # 把a中的o替换成0 不会修改原字符串
print(a.split(",")) # 把a以逗号分割成列表 不会修改原字符串
print(",".join(["1","2","3"])) # 把列表以逗号连接成字符串 不会修改原列表 注意数组中存在非字符串元素会报错，无法拼接
a='Hello python' #将 Hello python 转换为大写
print('upper 全部大写:',a.upper())
#将 Hello python 转换为小写
print('lower 全部小写:',a.lower())
#将 Hello python 首字母大写
print('capitalize 首字母大写:',a.capitalize())
#将 Hello python 每个单词首字母转换为大写
print('title 每个单词首字母大写:',a.title())
#将 Hello python 字母大小写转换
print('swapcase 字母大小写转换:',a.swapcase())
输出
4
4
2
hell0, 0ne
['hello', ' one']
1,2,3
upper 全部大写: HELLO PYTHON
lower 全部小写: hello python
capitalize 首字母大写: Hello python
title 每个单词首字母大写: Hello Python
swapcase 字母大小写转换: hELLO PYTHON
startswith, endswith
startwith 检索字符串是否以指定字符串开始，
endwith 检索字符串是否以指定字符串结尾，
a='hello python'
print('是否以字符 h 开头:',a.startswith('h'))
print('是否以字符 h 结尾:',a.endswith('h'))
center, ljust, rjust
center 方法用于将一个字符串在一定宽度的区域居中显示，并在字符串的两侧填充指定的字符，默认填充空格。前面将的 format 方法和居中符号(^)，其实完全可以用 format 方法代替 center 方法实现同样的效果，只是使用 center 方法更简单，更直接一些。
ljust()返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串,默认是空格填充。
rjust()返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串。
a='TXT'
print(a.center(10,"*"))
print(a.center(10))
print(a.ljust(10,"*"))
print(a.rjust(10,"*"))
# 输出
'''
***TXT****
TXT
TXT*******
*******TXT
'''
lstrip：方法删除原字符串左边的空白字符
rstrip：方法删除原字符串右边的空白字符
strip：删除原字符串两端的空白字符
a=' hellopython '
print(a.strip())
print(a.lstrip())
print(a.rstrip())
其他方法
#是否为字母或数字
print("txt".isalnum())
#检测字符串是否只由字母组成(含汉字)
print("txt".isalpha())
#检测字符串是否只由数字组成
print("234.3".isdigit())
print("2343".isdigit())
#检测是否为空白符
print("txt\t\n".isspace())
print("\t\n".isspace())
#是否为大写字母
print("A".isupper())
print('Ab'.isupper())
#是否为小写字母
print("a".islower())
print("aB".islower())
4 流程控制语句
score = 66
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 70:
print("中等")
elif score >= 60:
print("及格")
else:
print("不及格")
age = 20
print("成年人" if age > 18 else "未成年人")
5 循环语句
while 与 for两种形式
num = 1
sum = 0
while num <= 100:
sum += num
num += 1
print("1到100的和为:", sum)
sum = 0
for i in range(1, 101):
if(i % 2 == 0):
continue # 跳过当前 不退出循环 不将偶数纳入考虑
sum += i
if sum > 100:
break # 直接退出循环
print(sum)
6 内建数据结构
list，tuple, set，dict
6.1 list列表
通过[]创建list
常见函数：append,extend,insert,del,pop,remove,sort,index, len, min, max
切片特性 range函数等
# 所有这些函数都会直接修改a的值
a = [1,2,3]
# 索引访问元素
a[0] # 1
a[2] # 3
a[2] = 4 # 修改list元素
a[2] = 2
# 索引可以写负数，表示倒数第几个
a[-1] # 3
a[-2] # 2
a.append(4) # 在后面添加值 [1,2,3, 4]
a.extend([5,6]) # 合并另一个list [1,2,3, 4, 5, 6]
a.insert(0,7) # 在0位置插入7 [7, 1,2,3, 4, 5, 6]
a.pop() # 弹出并返回最后一个值 [7, 1,2,3, 4, 5]
a.remove(1) # 移除元素1 如果有多个首先删除index小的 [7, 2,3, 4, 5, 6]
a.index(1) # 1 从列表中搜索第一个出现的1 的索引 没有找到对应值索引会报错
a.index(4, 2) # 从列表索引为2 的位置开始 搜索4出现的索引位置
a.index(4, 2， 5) # 从列表索引为2开始，索引5结束 搜索4出现的索引位置
a.count(2) # 统计2在a中出现的次数
a.reverse() # 将列表反转 会改变原数组
c = sorted(a) # 将a排序返回排序后的数组 a的顺序将不会改变
a.clear() # 清空a []
# list的遍历
for i in a:
print(i)
index = 0
while index < len(a):
print(a[index])
index += 1
min(a) # 求列表最小值
max(a) # 列表最大值
len(a) # 列表长度
b = [1]
b*3 # 列表的乘法 [1, 1, 1]
a.sort() # 排序 默认从小到大 可以通过添加reverse=True从大到小 [2,3,4,5,6,7]
del a # 删除a所占的内存，访问a会报undifined错误 del(a)是一样的功能
# 二维列表 list元素为list
l = [[1,2,3], [4,5,6]]
for i in range(len(l)):
for j in range(len(l[0])):
print(l[i][j])
列表切片：
列表切片我认为是python中很重要很强大的一个特性，它可以帮助我们很快的从一个数组中提取出元素，如下，
a = [1,2,3,4,5,6,7,8]
b = a[:] # 可以很好的帮助我们复制一个list
id(b) == id(a) # Fasle
b = a
id(b) == id(a) # True
a[:4] # [1,2,3,4] 提取索引0-3的list
a[1:4] # [2,3,4] 提取索引1-3的list
a[0:4:2] # 步长为2 提取所以0-3的list [1,3]
a[::2] # 注意简写 第一个冒号前为开始索引（默认为0） 第二个冒号前为结束索引（默认为list长度） 第二个冒号后为步长（默认为1）
range()函数也可以创建列表 range(start, end, step)：创建[start, end)的数组，其中step为步长
如下
range(5) #[0,1,2,3,4]
range(1,5) #[1,2,3,4]
range(0,5,2) #[0,2,4]
range(3, -10, -1) #[3,2,1,0,-1,-2,-3,-4,-5,-6,-7,-8,-9]
enumerate函数：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。如下
a = ["q", "w", "e", "r"]
for i, item in enumerate(a):
print("第{}个元素为{}".format(i+1, item), end=';')
# 1个元素为q;第2个元素为w;第3个元素为e;第4个元素为r;
6.2 tuple元组
通过()创建元组，小括号可以省略
a = 1,2,3,4,5
b = (1,2,3,4,5)
c = (1,) # 只有一个元素的时候 最后一个,必须有
d = () # 创建一个空的元组
e = tuple(range(3)) # 可以使用tuple创建元组
元组不可修改
a = 1,2,3,4
a[1] = 5 # 这个会报错 因为元组不允许修改
a[:2] # (1,2) 同样 元组支持切片
b = sorted(a) # sorted可以对元组进行排序
a = (1,2,3)
b = (4,5,6)
a * 2 # 返回的是(1,2,3,1,2,3) 相当于复制内容
a + b # 返回的是（1,2,3,4,5,6）， 如果是两个list也是合并操作
zip函数
a = [10, 20, 30]
b = [40, 50, 60]
c = [70, 80, 90]
d = zip(a, b, c)
print(list(d)) # [(10, 40, 70). (20, 50, 80), (30, 60, 90)]
6.3 字典
字典在其他的语言中又称为map，以key:value的形式存在，
# 字典的创建
info = {'name':'班⻓', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
b = dict(name='maple',age=18,job='programmer')
c = dict([("name","maple"),("age",18),("job",'programmer')])
a = dict.fromkeys(['name', 'age', 'job']) # 通过fromkeys创建值为空的字典
print(a) # {'name': None, 'age': None, 'job': None}
# 字典的访问
age = info['age'] # 不存在将抛出异常
age = info.get('age')#'age'键不存在，所以age为None
# 若info中不存在'age'这个键，就返回默认值18
age = info.get('age', 18)
a = {"name": "maple", "age": 18, "score": 100}
print(a.items()) # key-value对
print(a.keys()) # 所有的key
print(a.values()) # 所以的valu
for key in a.keys():
print(a[key])
# 添加与修改元素
info['school'] = "aaa"
info['age'] = 20
a = {'name':'1','age':18,'job':'programmer'}
b = {'name':'2','money':1000,'sex':'male'}
a.update(b)
print(a) # {'name': '2', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': 'male'}
a = dict.fromkeys(['name', 'age', 'job']) # 通过fromkeys创建值为空的字典
print(a) # {'name': None, 'age': None, 'job': None}
a.popitem() # {'name': None, 'age': None}
print(a)
# 删除元素
del info['name']
del(info['name'])
# 删除整个字典，info被销毁了
del info
del(info)
info.clear() #只是清空info中的元素 info还没有被销毁
6.4 集合
使用{}创建，集合是无序可变，元素不能重复。可以存储不同数据类型的数据
a = {1,2,3,4}
c = {3,4,True,'abc',56.4}
b = [1,2,3,4,1]
c = set(b)
print(c) # {1, 2, 3, 4}
c.add(5) # {1,2,3,4,5} 元素新增
c.remove(4) # {1,2,3,5} 元素移除
c.clear() # {} 集合清空
print(c)
b = [1,2,3,4,1]
c = set(b)
c.add(5) # {1,2,3,4,5}
c.remove(4) # {1,2,3,5}
c.clear() # {}
print(c)
# 集合的 并 交 差 集
a = {1,3,2}
b = {'a','b','c', 2, 1}
print('并集：',a|b) #并集
print('并集：',a.union(b)) #并集
print('交集：',a&b) #交集
print('交集：',a.intersection(b)) #交集
print('差集：',a-b) #差集
print('差集：',a.difference(b)) #差集
7 函数
类似于高中数学中的函数 f(x)=x+1，python中的 函数同样也是接收输入，给出输出值。当然在python中的函数可以不返回特定的值，可以只在函数中做相关的处理。
使用def关键字定义函数
# 有返回值的函数示例
def judgeAdult(age): # 一般称 age为形参
if age >= 18:
return "成年人"
else:
return "未成年"
# 无返回值的函数示例
def isPass(score):
if score >= 60:
print("通过")
else:
print("不通过)
函数调用
let a = judgeAdult(20) # 这里对应的 age = 20 我们称20为实参
print(a) # 成年人
isPass(61) # 通过
局部作用域与全局作用域
# 全局变量 y
y = 1
def add(x):
# 局部变量 x
return x + y
print(2) # 3
def add2(x, y):
# 当局部变量与全局变量冲突时，就近原则，取局部变量
return x + y
print(add2(2,2)) # 4
def add3(x):
y = 2
return x + y
print(add3(5)) # 7
print(y) # 1 全局变量没修改
# 如果我们需要修改全局变量，我们需要借助global关键字
def add4(x):
global y
y = 2
return x + y
print(add4(6)) #8
print(y) # 2
函数的参数
- 位置参数
- 默认参数
- 关键字参数
- 可变参数
def add(x, y, z):
return x+y+z
add(1,2,3) # x=1 y =2 z=3 根据位置意义对应
add(1,2) # 报错 无法对应上
def add(x, y, z=1):
return x + y + z
add(1,2,3) # x=1 y =2 z=3 默认参数会被覆盖
add(1,2) # x=1 y=2 z=1 不传值是默认参数赋值默认值
add(z=3,x=1,y=2) # 我们可以通过指定参数赋值 （关键字参数）
# 可变参数 *z以元组形式出现 **以字典形式出现
def add(x, y, *z):
print(x, y, z)
def add2(x, y, **z):
print(x, y, z)
add(1,2,10,11) # 1 2 (10, 11)
add2(1,2, name="maple", age=18) # 1 2 {'name': 'maple', 'age': 18}
eval函数： 用来执行一个字符串表达式
a = eval("([1,2], [3,4], [5,6], [7,8], (9,0))")
a = eval("[1,2,3,4]")
b = eval("1+1")
51万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
