python基础笔记

# Python GuideBook

 

 

python基础语法

 

 

注释：解释代码，不会被执行

  • 单行

 # This is an paragraph to explain your pyCode

  • 多行

 """
                           .]@]`                   
                         .@/.\@.                  
        =@@@`.          .@@..=@`                  
        =@..\@`         =@`..=@`                  
        =@^..,@\.   .]o/\@...=@.       ..,]]]`    
         \@`...\@. =^***=@..=@/\/@@@@@@@@@@@OO@`  
         .\@\`.*O@`o]O@@@@\/@@@@@@@@@@@OOO@@OO@^  
           .o/[**,[oO@@@@@@@@@@@@@@@@@OOOOO@@@@^  
         .=/*******]oO@@@@@@@@@OO@@OOO@@O@@@@@@^  
       ...^****]OOO@@@@@@@@@@@@OOOO@@@O@@OoooO^   
    .=/[,\oO@@@O//[[`=oO@@@@OOO@@@@@@@@@Oo****o.  
    =^****/o]]*,[]]]][]`,,/O@@@@@@@@@@@@@o****=^. 
  .,/\**,oo********,*`/`][]/^O@@@@@@@@@@@Oo`**//\`
 .o**,Ooo[]*******=^,O@@@@@^\*\@@@@@@@@@@@@Oo/***o
 =^**=@[/O\,,****\==O@@@@@@@\`\=@@@@@@@@@@@@Ooooo^
 .\`*OOo@@@@/****^*/@@@@@@@@@/\=@@@@@@@@@@O/*****\
   .[@OO@@@@@^/`,===@@@@@@O\@@^/=@@@@@@@@@o******o
     =@=@OOO@O,^=*/o@\`**`**,@^^o@@@@@@@@Oo*****,/
     =@^@^**\@`^^=^^@\,*`****@O`=@@@@@@@@Oo****,o.
     .@OOO**=@o*,^==\@******,@^^O@@@@@@@@@O\*,/`. 
      =@/O/`*@/=]=]/*O@`,**,O@\\@@@@@@@@@@@`...   
       =@^O@O@/\/*o,^/O@@@@@O/O@@OO@@OO@@@@       
        ,@O/OO@@O/*=**\]o/\/\@@@@@@@@@@/,@@\.     
         .,@@@/^/``/,/\^]O@@@@@@@@@@[O@^ .,[`     
             \@\[,[*O@@@@^   .=@@`   ,@@@.        
              ,\@O```@^,\/    .\@@^    ,[.        
               .@O\/O@\.         ,..              
               .\@\=,/@^                          
           
 """

 

 

变量：存储数据的内存地址的名字

变量定义：

 变量名 = 数据

变量名自定义，但要满足标识符命名规则。

  • 由数字，字母，下划线组成。

  • 开头不能是数字

  • 不能用内置关键字

  • 严格区分大小写

命名规则：

  • 见名知义

  • 大驼峰：UserName

  • 小驼峰：userName

  • 下划线：user_name

 

 

debug：先打断点，后右键调试，一行一行执行。

 

数据类型：

 

 
 
 
 
 
 
 
 
 
 
 
 
数据类型
数值
float
int
布尔型
True
False
str
list
tuple
set
dict
 

检测数据的类型：

 print(type(yourData))

 

 

输出，格式化的输出！

输出即程序运行将数据呈现在控制台让人看。

 para_time = 200
 para_stuff = "得志，与民由之；\n不得志，独行其道。\n富贵不能淫，贫贱不能移，威武不能屈。"
 print("《孟子·滕文公下》\n公元%d\n%s" % (para_time, para_stuff))

格式化符号：

格式符号转换
%s 字符串
%d 有符号的十进制整数
%f 浮点数
%c 字符
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数（小写ox）
%X 十六进制整数（大写OX）
%e 科学计数法（小写'e'）
%E 科学计数法（大写'E'）
%g %f和%e的简写
... ...
... ...
... ...

格式化规则：

  • %06d，表示输出的整数显示位数，不足以0补全；超出位数原样输出。

  • %.2f，表示小数点后显示2位小数。

format格式化：（python3.6 later）

 para_name = "《孟子·滕文公下》"
 para_time = 200
 para_stuff = """
 得志，与民由之；
 不得志，独行其道。
 富贵不能淫，贫贱不能移，威武不能屈。
 """
 print(f"{para_name:^20}\n{para_time:.^25}\n{para_stuff}", end="\n", sup="")
 ​

  • f"{变量:(补齐字符)(对齐方式)(宽度)}"

转义字符："\"

 

 

 

输入，接受数据！

 

 password = input("please enter your password:")

input接受的数据都会是str型，一些情况下需要类型转换。

函数说明
float(x) 将x转换为浮点数
complex(x,y) 构建以x为实部，y为虚部的复数
str(x) 将x转换为字符串
tuple(s) 将序列s转化为一个元组
eval(str) 去除“”，该是什么就是什么(list,tuple,set)
list(s) 将序列转化为一个列表
chr(x) 将一个整数x转化成一个Unicode字符
ord(x) 将一个字符转化为它的ASCII整数值
hex(x) 将一个整数转化为一个十六进制字符串
oct(x) 将一个整数转化为一个八进制字符串
bin(x) 将一个整数转化为一个二进制字符串
   
   
   

 

p1 = input("please enter:").split(",")
c1 = complex(int(p1[0]), int(p1[1]))
print(c1)

 

 

 

 

运算符：不仅是数字运算

算数运算符&复合赋值：

运算符描述
+/+= 加
-/-= 减
* 乘
/ 除
// 整除
% 取余
** 指数
() 提高运算优先级的括号

赋值运算符：

运算符描述
= 赋值 
p1, p2, p3 = 'a', 'b', 'c'
a = b = 10

比较运算符：

运算符
==
!=
>
<
>=
<=

返回布尔值

逻辑运算符：

运算符
and
or
not

返回布尔值

数字的逻辑运算：

  • and运算符：只要有一个值为0，则结果为0，否则结果为最后一个非0数字。

  • or运算符：只有所有值为0结果才为0，否则结果为第一个非0数字。

 

 

 

 

 

条件分支：道路上的分叉路口！

#单分支
if True:
    print(True)
#双分支
if False:
    print(False)
else:
    print(True)
#多分支：

三目运算符：（双分支）

a=1
b=2

c=a if a>b else b
print(c)

 

 

 

循环&遍历：重复？挨个执行！

while 条件：
	执行语句
    continue
    计数器
    break

下一次循环：continue

跳出循环：break

i = 0
for i in range(10):
    if i % 2 == 0:
        # continue
        break
    print(i)
#九九乘法表(for)
for i in range(0,10):
    for j in range(0,i+1):
        print(i,"*",j,"=",(i*j),end="\t")
    print()
#九九乘法表(while)
i = 0
while i < 10:
    j = 0
    while j < (i+1):
        print(i, "*", j, "=", (i * j), end="\t")
        j += 1
    print()
    i += 1

while...else(for...else)   ? 这是必经之路嘛？

while 条件:
    条件成立，重复执行，直至结束。
    #continue
    #break
else:
    循环结束后要执行的语句。
#!!!else可以检测while是否进行。

continue退出当前一次循环，继续下一次循环，所以该循环continue控制下可以正常结束，会执行else代码段。(break非正常终止，不执行else)

 

 

 

 

 

字符串：（不可变数据类型：操作后原字串不变）

下标：(索引号)从0分配直到-1, 计算机内存分配的。

切片：对操作对象截取其中的一部分，字串，元组，列表都支持。

序列[起点下标：结束下标：步长]

不包含结束下标对应的数据，正负整数均可。

步长是选取间隔，正负均可，default = 1。

#倒序打印：
a = 'abcdefghijklmnopqrstuvwxyz'
print(a[::-1])

字串写法：单引号，双引号，三引号包裹。

字符串常见操作函数：(查找，修改，判断)

查找：

#.find()
字符串序列.find(subStr, startsignNum, endsignNum)
#若查找到：返回子串在原字串中的首个索引值
#若查不到：返回-1
#.index()
#和find语法功能基本一致，不同之处是若找不到subStr会报错！
#.count(subStr, start, end)
#记录subStr在字串中出现的次数

修改：

#替换：	.replace(旧子串, 新子串, 替换次数)-->替换次数：啥都不写默认全换，负数也全换。
#分割：	.split(分割字符, 分割次数（从左到右数）)-->返回列表
#插入：	.join(多个字符串组成的序列，只能是字符串)
#字串第一个字符转大写,其余字符转小写：str.capitalize()
#字串中每个单词首字母转成大写，其余转小写：str.title()
#字串转小写：str.lower()
#字串转大写：str.upper()
#删除空白字符：str.lstrip()-->删除左侧空白
#			str.rstrip()-->删除右侧空白
#			str.strip()-->删除两侧空白字符
#对齐与格式化：
#			str.ljust(长度, 填充字符)
#			str.rjust(长度, 填充字符)
#			str.center(长度，填充字符)-->绝对居中：长度为奇数。

判断：

字串序列.startwith(子串, 开始位置, 结束位置)
字串序列.endwith(子串, 开始位置, 结束位置)
返回布尔值

 

 

 

 

 

列表：(可变数据类型，操作后原列表改变)

列表的常用操作:

查找：

  • 下标查找

natu_list = [1,2,3,4,5,6]
print(list[0]) #1

  • .index()

  • .count()

  • len(obj_list)-->公共方法，返回长度（数据个数）。

判断：

  • in

  • not in

增加：

  • .append(数据)

  • .extend(数据)

数据为序列：append会将整个序列添加，extend会将序列内数据逐一添加至列表。

  • .insert(位置下标, 数据)

删除：

  • del 数据

del natu_list  #删除整个变量
del natu_list[0]  #删除第一个元素

  • .pop() -->删除指定下标的数据(默认最后一个)，并返回该数据

列表序列.pop(下标)

  • .remove(数据) -->删除列表指定数据的第一个匹配项。

  • .clear() -->清空列表，保留空列表。

修改：

  • 修改指定下标的数据（重写入）

  • 逆置：.reverse()

  • 排序：.sort(reverse=False) -->reverse=False升序（默认），reverse=True降序(高-->低)

  • 复制：.copy()

列表的遍历：

#while：
aL = [1, 2, 3, 4, 5]
i = 0
while i < len(aL):
    print(aL[i])
    i += 1

    
#for：
aL = [1, 2, 3, 4, 5]
for i in aL:
    print(i)

列表嵌套：

list_ = [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
#查找b
print(list_[0][1])
#教师分配入办公室
from random import randint

a = [[], [], []]
p = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
for i in p:
    a[randint(0,2)].append(i)
print(a)

 

 

 

 

元组：保护重要数据

元组和列表一样，只是元组内的数据不能修改，列表的数据可以修改。

  • 注意：单个数据存在元组要加“，”

元组常见操作：（只支持查找）

  • 下标查找

  • .index()

  • .count()

  • len()

元组里若有列表，修改列表里的数据是可以的。

tu = ("a", 1, 2, ["a", 4, 5])
tu[-1][1] = "j"
print(tu)

 

 

 

 

 

 

字典：键值配对

字典常见操作：

增：

字典名[键] = 值
d1 = {"name" : 123}
d1['id']='ryan'
print(d1)

删：

  • del()/del：删除字典或删除字典中指定的键值对。

  • .clear() -->清空列表

改：

  • 字典序列[key] = 值

查：

  • dict[key]查找，有：返回值；无：报错。

  • 字典序列.get(key, 默认值) -->查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数则返回None。

字典的循环遍历：

#键的遍历：
for key in d1.keys():
    print(key)

#值的遍历：
for value in d1.values():
    print(value)
    
#键值对的遍历：
for item in d1.items():
    print(item)
    
#键值对的遍历：拆包
for key, value in d1.items()：
	print(f'{key} : {value}')

 

 

 

 

集合：没有两片叶子是完全一致的！

创建集合：{}；set()

集合：去重！

集合常见操作方法：

增加数据：

  • .add(数据)

  • .update(序列数据)

s1 = set()
s1.update((100,90,80))
print(s1, type(s1))

删除数据：

  • .remove(数据)，删除集合中的指定数据，若数据不存在则报错。

  • .discard(数据)，删除集合中的指定数据，若数据不存在也不会报错。

  • .pop()，随机删除集合中的某个数据，并返回这个数据。

查找数据：

  • in

  • not in

返回布尔值。

 

 

 

 

 

 

公共操作：原来这些是通用的！

  • 运算符

  • 公共方法

  • 容器类型转换

运算符：

运算符描述支持的容器类型
+ 合并 字符串，列表，元组
* 复制 字符串，列表，元组
in 元素是否存在 字符串，列表，元组，字典
not in 元素是否不存在 字符串，列表，元组，字典

公共方法：

函数描述
len() 计算容器中元素个数
del 或 del() 删除
max() 返回容器中元素最大值
min() 返回容器中元素最小值
range(start,end,step) 生成从start到(end+1)的数字，步长为step，供for循环使用
enumerate(可遍历对象, start=0) 函数用于将一个可遍历的数据对象(如列表，元组，字串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。

容器类型转换（数据类型转换）：

  • tuple()

  • list()

  • set()

 

 

 

 

 

 

 

生成式？推导式？更少的代码！

  • 列表生成式

  • 字典生成式

  • 集合生成式

列表生成式：

生成一个0~20的列表：

# while实现：
n_list = list()
i = 0
while i < 21:
    n_list.append(i)
    i += 1
print(n_list)
# for实现：
n_list = list()
for i in range(21):
    n_list.append(i)
print(n_list)
# 列表生成式实现：
n_list = [i for i in range(21)]
print(n_list)

创建一个0~20的偶数列表：

# 列表生成式实现：
n_list = [i for i in range(0, 21, 2)]
print(n_list)

创建一个0~100内整除7的列表：

n7_list = [i for i in range(101) if i % 7 == 0]
print(n7_list)

创建一个两个人玩石头剪刀布所有可能的列表：（rock=0,cut=1,cloth=2）

n8 = [(i,j) for i in range(3) for j in range(3)]
print(n8)

字典生成式：

生成一个字典，字典key是0~20的奇数，value是这个数的二次方。

d1 = {i:i**2 for i in range(-1,21,2)}
print(d1)

将两个列表合并成一个字典：

list1 = [i for i in range(21)]
list2 = [(i**2) for i in range(21)]
print(list1)
print(list2)
d1 = {list1[i]:list2[i] for i in range(len(list1))} #!!!
print(d1)

提取目标数据：

#提取生命值在100+的职业：
_hp = {"战士": 100, "法师": 60, "骑士": 130, "弓箭手": 75, "火铳手": 90, "牧师": 80}
_100 = {key: value for key,value in _hp.items() if value >= 100}
print(_100)

集合生成式：

# 生成对应列表中个元素的平方数
list1 = [i for i in range(21)]

print(list1)
s1 = {((list1[i])**2) for i in range(len(list1))}
print(sorted(s1))

集合有去重的功能：

list1 = [1, 1, 2, 3, 4, 4, 5, 6]
s1 = {((list1[i])**2) for i in range(len(list1))}
print(sorted(s1))

 

 

 

 

 

函数：打包代码带回家！

写函数的好处：封装代码，高效的代码复用。

用函数：先定义，后调用。

#定义
def 函数名(参数):
    """函数的说明文档"""
    代码...
    ......
    return 返回值

return: 存储返回值，并且结束函数。

#调用
函数(参数)

函数说明的查看：help()

变量作用域：局部变量(定义在函数体内部的变量)；全局变量(在函数外定义)

在函数里修改全局变量：global 全局变量

返回值：可以返回多个值，默认是以元组的类型存储。当然也可以改类型。

不定长参数：

def user_info(*args):
    print(args)

def user_info(**kwargs):
    print(kwargs)
user_info(name='bb', age=19, id='cs0740')

拆包：

# 元组拆包
def re_num():
    return tuple(i for i in range(2))
print(re_num())
print(type(re_num()))

num1, num2 = re_num()
print(num1)
print(num2)

# 字典拆包
def re_dt():
    return {i: i**2 for i in range(2)}
a, b = re_dt()
print(re_dt()[0])

引用：

在python中，值是靠引用来传递的。

a=1
print(id(a))
b=1
print(id(b))
a=[1]
print(id(a))
b=[1]
print(id(a))

可变类型和不可变类型：

  • 可变类型

    • 列表

    • 集合

    • 字典

  • 不可变类型

    • 字符串

    • 元组

    • 整型

    • 浮点型

递归：

  • 函数自己调用自己

  • 有出口return

  • 有递归深度

lambda 表达式：lambda 参数: 返回值

###

 

 

 

 

 

 

 

 

 

高阶函数：函数作为参数！

  • abs() -->绝对值

  • round() -->四舍五入

def ab_(a, b, f):
    return f(a)+f(b)

print(ab_(-1, -2, abs))

  • map(func, list)

#序列的函数操作
def funcal(x):
    return x * 2
l1 = [i for i in range(3)]
print(list(map(funcal, l1)))

  • reduce(func, list) #func 至少要两个参数

#序列累计运算
import functools
def funcal(x, y):
    return x * y
l1 = [i for i in range(3)]

re = functools.reduce(funcal, l1)
print(re)

  • filter(func, list)

#filter 过滤列表
def funcal(x):
    return x%2 == 0
l1 = [i for i in range(3)]

re = filter(funcal, l1)
print(list(re))

 

 

 

 

 

 

 

 

 

文件：去操作其他文件！

打开文件

  • open("目标文件"， 操作模式)

f = open('info_.txt', 'w')
f.write('eee')
f.close()

操作模式：

modesubscripts
r 只读的方式打开文件。读写针头放在文件的开头，默认的模式。
rb 以二进制格式打开文件用于只读。
r+ 打开一个文件用于读写。
rb+ 以二进制格式打开用于读写。
w 打开一个文件用于写入，会覆盖原内容，若文件不存在则创建。
wb 二进制写入
w+ 写入与w基本功能一致
wb+ 二进制打开写入
a 追加内容，若文件不存在则创建。

读取文件：

  • read()

文件对象.read(num)
# num 表示要从文件中读取的数据的长度（单位是字节），如果没有传入num,那么
#就表示读取文件中所有的数据。

  • readlines()

#readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一
#个列表，每一行是一个元素。
f = open('info_.txt', 'r')

pa1 = f.readlines()

print(pa1)
f.close()
#读取时注意要将mode值设为只读。

  • readline() -->一次读取一行内容

  • .seek()

文件对象.seek(偏移量, 起始位置)
#起始位置：0-->开头， 1-->当前位置，2文件结尾。

  • 文件与文件夹操做

import os

os.rename()

os.remove()

os.mkdir()

os.rmdir()

os.getcwd()

os.chdir()

os.listdir()

posted @ 2021-09-11 18:16  昵称hasbeenused  阅读(89)  评论(0)    收藏  举报