关于Python

python是面向对象的强类型动态脚本语言
python是面向对象的解释型高级编程语言

编写第一个程序

语言学习第一步，编写的第一个程序”你好世界”

1
print("hello,world")

关于bug

遇到bug，多看，多思考，多尝试

常见的bug：

  1. 输入错误(中文符号)
  2. 缩进错误(print要顶格写，不然就报错)
  3. 语法错误(syntax error)
  4. 命名错误(字符串要加引号)

debug调试

  1. debug中代码为蓝色时表示代码正在运行
  2. 步过是执行下一条，步出是执行下一个断点
  3. 可以通过debug的调试看到程序执行的顺序

注释与快捷键

注释可以放在任意位置但是注释的内容不会执行

#是单行注释
“””
三个引号是多行注释
“””

  1. ctrl+/是快捷注释使用单行注释
  2. ctrl+z是撤销
  3. ctrl+y是反撤销
  4. ctrl+f是查找
  5. ctrl+h是替换
  6. ctrl+d是复制到下一行

输出函数

1
2
print()
print("hello","world",sep="*")

输出:hello*world

  1. 输出多个值的时候，用逗号隔开
  2. separator=分隔符,用来间隔多个值，放在最后
  3. end=结尾符，用来表示输出的结束，默认为换行符，\n,放在最后

变量

  1. 计算机中的存储空间，用于保存数据
  2. 定义变量的格式 变量名=值
  3. 首次使用变量会在内存中划分空间，再次使用变量便直接修改原空间的值
  4. 变量可以被反复赋值并且可以是不同类型的值

标识符

标识符就是变量，函数，类，模块的名字

标识符的命名规则：

  1. 由字母，数字，下划线组成
  2. 不能以数字开头
  3. 不能与关键字重名
  4. 严格区分大小写
  5. 见名知意
  6. 标识符被包含在括号内是不会对标识符产生影响

数据类型

数值类型分为:

整数类型：int

任意大小的整数num=100检测数据类型的方法type()

浮点数类型：float

num2=1.5

复数类型：complex

固定写法：z=a+bj(a是实部，b是虚部，j是虚数的单位不能改成其他的)

布尔类型：bool(通常用判断)

有固定写法，一个为True，一个为False(必须严格区分大小写)
布尔值可以当作整数使用，True为1，False为0

字符串类型：str

特点：需要加上引号，包含了多行内容可以使用三引号

占位符:

生成一定格式的字符串，类似于c语言
占位符只会占据位置并不会输出内容

%

%s

字符串占位符

%d

整数占位符 

1
2
3
name='ay'
age=18
print('%s,%d'%(name, age)) #ay,18

%4d整数占位符

数字设置位数，不足前面补空白

1
2
a=123
print("%04d"%a) #0123

表示输出的整数显示位数，不足的话用0补全，超出的话按原样输出

浮点数占位符

默认后六位小数,遵循四舍五入原则

%%

%% 被解释为一个百分号

1
print("我是%%的%%" % ()) #我是%的%

f格式化

格式：f'字符串{表达式}'

1
2
3
name = "***"
age = 18
print(f"我的年龄是{age},我的名字是{name}") #我的年龄是18,我的名字是***

数值运算：+ - * / // * **

/

(商一定是浮点数且除数不能为0)

//

(取整除，取商的整数部分，向下取整忽略小数，若表达式里有浮点数，结果也会用浮点数表示)

%

(取余数，只取余数部分)

**

(幂，m**n：m的n次方)

算术优先级：**幂 > *乘 /除 //取余 %取整> +加 -减

括号可以提升优先级

赋值运算符：= += -= *= /= //= **= %=

(纯数字不能使用而且没有定义的变量也不能使用)

1
2
3
4
a=10
b=20
a+=b
print(a) #30

输入函数：input()

1
2
3
input(prompt) #prompt是提示信息
name=input("请输入：")
print(name)

转义字符

\n

换行

\t

制表符(通常表示空四个字符，也称缩进)

\r

回车(表示将当前位置移到本行开头)

\

反斜杠

r

原生字符串,表示字符串内的所有转义字符无效

逻辑判断

if判断

if 要判断的条件：
条件成立的时候要做的事情

1
2
3
4
age=int (input("请输入年龄："))
if age >= 18:
    print("允许")
else:print("不允许") #输入15，输出不允许

if else(二选一)

基本格式：
if 条件:
条件成立时要做的事情
else:
条件不成立时要做的事情

if elif(多选一)

基本格式：
if 条件1:
条件1成立时要做的事情
elif 条件2:
条件2成立时要做的事情
elif 条件3:
条件3成立时要做的事情
else:
以上条件都不成立时要做的事情

if嵌套

基本格式：
if 条件1:
条件1成立时要做的事情
if 条件2:
条件2成立时要做的事情
else:
以上条件都不满足时要做的事情

内层外层都可以使用if else结构

1
2
3
4
5
6
7
8
9
10
ticket=True
knife_length=30
if ticket==True:
    print("有车票，可以进站")
    if knife_length>=20:
        print("不允许携带20cm以上的刀进入")
    else:
        print("安检通过")
else:
        print("没票不能进")

运算符

比较运算符：== != > < >= <=

  1. == 比较的是两个值是否相等，相等的话就返回为真True，不相等就返回为假False
  2. != 比较两个变量的值是否相等，不相等返回真True，相等返回假False

逻辑运算符 : and,or,not(与 或 非)

  1. and左右两边都符合才为真
  2. or左右两边有一个符合就为真
  3. not表示相反的结果 not True=False, not False=True

三目运算符

为真结果 if 判断条件 else 为假结果

循环

循环的作用：让代码更高效的重复执行

while

while 条件:
条件成立时要做的事情
改变变量

1
2
3
4
i=1
while i<100:
    i=i+1
    print('好好学习天天向上') #输出99次好好学习天天向上

如果条件不是False或者0，就一直循环，直到条件为False或者0时退出循环

1
2
3
4
5
6
i=1  
s=0
while i<=100:
 s += i
 i += 1
print(s) #输出5050
while嵌套
1
2
3
4
5
6
7
基本格式:
while 条件1:  
    条件1成立时要做的事情  
    while 条件2:  
        条件2成立时要做的事情   
改变变量2
改变变量1

缩进决定层级，严格控制缩进

1
2
3
4
5
6
7
8
i=1
while i<=3:
    print(f"这是第{i}次外层循环")
    j=1
    while j<=5:
        print(f"这是第{j}次内层循环")
        j+=1
    i+=1

外循环执行一次，内循环执行五次

for循环

1
2
3
基本格式：
 for 临时变量 in 可迭代对象:
     循环体

*缩进决定层级，严格控制缩进
(字符串是可迭代对象)

1
2
3
4
5
range(start,stop,step)
 str="hello world"
 for i in str:
     print(i)
#遍历每一个字符

range()函数

可以生成一个数据序列，通常在for循环中使用

1
2
for i in range(1,6): #(包前不包后,只写一个数就是循环次数,而且从0开始)
    print(i) #输出12345
1
2
3
4
5
#for循环从1加到100
 sum=0
 for i in  range(1,101):
     sum+=i
 print(sum)

break和continue

break和continue都是专门在循环中使用的关键字
break表示某一条件满足时立即退出循环

1
2
3
4
5
6
7
i=1
while i<=5:
    print(f"小红在吃第{i}个苹果")
    if i==3:
        print("吃饱了不吃了")
        break
    i+=1 #输出小红在吃第1个苹果 小红在吃第2个苹果 小红在吃第3个苹果 吃饱了不吃了

continue表示立即结束本次循环，直接进入下一次循环

1
2
3
4
5
6
7
8
i=1
while i<=5:
    print(f"小明在吃第{i}个苹果")
    if i==3:
        print("吃了一个虫子，这个苹果不吃了")
        i+=1 #在continue之前一定要修改计数器，否则会进入死循环
        continue
    i+=1
1
2
3
4
5
for i in range(5):
    if i==3:
        #break 当i=3时，结束整个循环
        #continue 跳过当i=3时的循环，继续执行后续的循环
    print(i)

字符串编码

字符串编码本质上就是二进制与语言文字的一一对应关系

ASCII码

ASCII码一共规定了128个字符的编码，只用来表示常用的字符

Unicode编码

Unicode编码所有字符都是两个字节，转换速度快但是浪费空间

GB2312编码

GB2312编码是中国制定的一套字符编码，它是对Unicode编码的一种压缩和优化，只包含了6763个常用汉字和符号

UTF-8编码

  1. UTF-8编码是一种可变长度的Unicode编码，它可以使用1~4个字节表示一个字符，根据字符的不同，使用的字节数也不同
  2. UTF-8编码的优点是兼容性好，支持所有语言，缺点是编码效率低

字符串编码转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a=('hello')
print(a,type(a))

a1=a.encode()
print('编码后：a1',type(a1))

a2=a1.decode()
print('解码后：a2',type(a2))

st='你好'
st1=st.encode("utf-8")
print(st1,type(st1))

st2=st1.decode("utf-8")
print(st2,type(st2))

字符串运算符

+

(连接字符串)

*

(重复输出)

成员运算符

  1. in (判断是否包含，包含返回True，不包含返回False)
  2. not in (判断是否不包含，不包含返回True，包含返回False)
1
2
name = "ay"
print('a' not in name) #False

下标

  1. 下标是用来访问字符串中单个字符的位置,可以快速找到对应的数据
  2. 从左往右下标从0开始，到字符串长度-1结束
1
2
3
4
name = "ay"
print(name[0]) #a
print(name[1]) #y
#从右往左下标从-1开始，到字符串长度*-1结束

切片

切片是指从一个字符串中获取一个子字符串 

1
2
3
4
5
6
7
8
9
10
11
12
13
>语法：
>1. 字符串[开始下标:结束下标:步长]，包前不包后  
>2. 步长默认为1，步长为正数时，从左往右取，步长为负数时，从右往左取  
>3. 开始下标默认为0，结束下标默认为字符串长度``` 
~~~python
name="abcdefg"
print(name[0:4]) #abcd
~~~
>1. 步长的绝对值大小绝定切取的间隔，正负号决定切取方向，默认为1
>2. 正数从左往右切，负数从右往左切
```python
name="abcdefg"
print(name[-1::-1]) #gfedcba

字符串常见操作

查找 find()

检测某个子字符串是否包含在字符串中，如果有那么返回子字符串在字符串中的下标，如果没有则返回-1
语法：字符串.find(子字符串，开始下标，结束下标) 

1
2
name="abcdefg"
print(name.find("cde",0,5)) #2

index()

检测某个子字符串是否包含在字符串中，如果有那么返回子字符串在字符串中的下标，如果没有则报错
语法：字符串.index(子字符串，开始下标，结束下标) 

1
2
name="abcdefg"
print(name.index("h")) #报错

count()

统计某个子字符串在字符串中出现的次数,没有就返回0
语法：字符串.count(子字符串，开始下标，结束下标) 

1
2
name="aaaabcdefg"
print(name.count("h")) #0

startswith()

检测字符串是否以某个子字符串开头，如果是返回True，否则返回False
语法：字符串.startswith(子字符串，开始下标，结束下标)
如果设置了开始下标和结束下标，那么检测的范围就是开始下标到结束下标-1

1
2
name="abcdefg"
print(name.startswith("a",0,8)) #True

endswith()

检测字符串是否以某个子字符串结尾，如果是返回True，否则返回False

1
2
name="abcdefg"
print(name.endswith("ab",0,8)) #False

isupper()

检测字符串是否都是大写字母，如果是返回True，否则返回False

1
2
name="ABCDEFG"
print(name.isupper()) #True

islower()

检测字符串是否都是小写字母，如果是返回True，否则返回False

1
2
name="abcdefg"
print(name.islower()) #True

isalpha()

检测字符串是否都是字母，如果是返回True，否则返回False

1
2
name="abcdefg"
print(name.isalpha()) #True

isdigit()

检测字符串是否都是数字，如果是返回True，否则返回False

1
2
name="123456"
print(name.isdigit()) #True

isalnum()

检测字符串是否都是字母和数字，如果是返回True，否则返回False

1
2
name="abcdefg123456"
print(name.isalnum()) #True

修改元素

replace()

替换字符串中的某个子字符串，如果没有找到则返回原字符串
语法：字符串.replace(旧子字符串，新子字符串，替换次数(默认全部替换))

1
2
name="abcdefg"
print(name.replace("a","A")) #Abcdefg

split()

按照指定的分隔符将字符串分割成一个列表
语法：字符串.split(分隔符，分割次数)，如果不包含分割内容，那么就不会进行分割

1
2
name="abccdefg"
print(name.split("c",1)) #['ab', 'cdefg']

capitalize()

将字符串的首字母大写

1
2
name="abcdefg"
print(name.capitalize()) #Abcdefg

title()

将字符串的每个单词的首字母大写

1
2
name="abcdefg"
print(name.title()) #Abcdefg

ower()

将字符串中的大写字母转换为小写字母

1
2
name="ABCDEFG"
# print(name.lower()) #abcdefg

upper()

将字符串中的小写字母转换为大写字母

1
2
name="abcdefg"
print(name.upper()) #ABCDEFG

join()

将序列中的元素以指定的字符连接生成一个新的字符串
语法：字符.join(序列)

1
2
name="abcdefg"
print("*".join(name)) #a*b*c*d*e*f*g

列表