python基本语法学习笔记

快速格式化win：ctrl+alt+l(layout)

输出函数的体验

# 我是单行注释
'''
    我是多行注释
'''
# 单引号和双引号都是一样的，都是字符串类型,其实三引号也行
print('我是管超龙')

#自动加换行
print("hello world")
#取消换行
print("hello world",end="")

#如果确定输出变量在字符串之后则可以直接
sex = '男'
print("性别", sex)

#格式化输出
sex='男'
print("性别%s" % sex)
sex = '男'
print("性别%c" % sex)
age = 666
print("年龄%d" % age)
age = 666.666
print("年龄%f" % age)
print("性别%s 年龄%d" % (sex , age))
age=20
print(f"年龄:{age}")#注意要加f

输入函数体验

password = input("password:")
#默认input返回的都是字符串
print(password)
print(type(password))
#需要对输入的内容进行操作时
num = int(input("password:"))
num += int(input("password:"))
#想要输出%需要使用%转义
print("最终密码：%f %%" % num)

#多组输入，空格分隔


n = int(input())
m = 1
while m <= n:
    # 默认类型为list
    a, b, c = input().split(' ')
    a = int(a)
    b = int(b)
    c = int(c)
    # print(a)
    # print(b)
    # print(c)
    if a + b <= c:
        print("Case #%d: false" % m)
    else:
        print("Case #%d: true" % m)
    m += 1

变量,数据类型

变量的类型取决于它存放的数据类型，所以声明时便需要初始化
变量可以被多次初始化改变类型

# 声明即定义
num = 10.3
num1 = 20
# tab键可以自动补齐
print(num+num1)

# 数据类型
# int
# float没有double型
# bool ==> True False
# string ==>'  ' "   "
# 元组和列表可以互相转化
# list()列表
# tuple()元组
# type()可以获取数据类型
num = False
#强制类型转换
num=int("666666")
print(type(num))
num=float(666666)
print(type(num))
num=str(666666)
print(type(num))
num=bool(666666)
print(type(num))
#不是四舍五入直接去掉小数部分
s = '12.6'
print(int(float(s)))
#非法操作,只能进行一步转化。
b=int("12.5")

标识符和关键字

标识符
python3支持汉字命名。
字母，下划线，数字组成，不能以数字开头
区分大小写
不能和关键字重复

小驼峰命名法：userName
大驼峰命名法：UserName
下划线连接法：user_name

关键字查询

import keyword
print(keyword.kwlist)

运算符

a = 10
b = 2
#浮点计算
c = a / b
print(c)
#整除
c = a // b
print(c)
#指数a的b次方
print(a**b)
#多变量赋值
a, b, c = 11, 12, 13

分支语句if

python的if语句将格式与语法结合，强制性要求了代码的美观。
选中加tab可以将多行进行格式对应。

if 条件:
    运行语句
    ......
elif 条件：
	运行语句
	......
else :
	运行语句
	...... 
#必须要有四个空格

age = int(input("请输入你的年龄："))
if age >= 18:
    # 只要是前面都是空四个空格就属于同一个判断语句
    print("网吧")
    print("恋爱")
    print("prohub")
else:
    print("NO 网吧")
    print("NO 恋爱")
    print("NO prohub")
#包含and的if判断
sex = '男'
if age >= 18 and sex == '男':
    print("网吧")
    print("恋爱")
    print("prohub")
else:
    print("一边玩去")
#包含or的if判断
sex = '女'
if age >= 18 or sex == '男':
    print("网吧")
    print("恋爱")
    print("prohub")
else:
    print("一边玩去")
#包含not的if判断
sex = '男'
if not age <= 18 and sex == '男':
    print("网吧")
    print("恋爱")
    print("prohub")
else:
    print("一边玩去")
#if的嵌套使用
sex = '男'
age = 16
if sex == '男':
    if age >= 18:
        print("网吧")
        print("恋爱")
        print("prohub")
    else:
        print("玩泥巴去")
    print("一边玩去")
else:
    print("绣花适合你")
    
#if-elif-else
sex = '男'
if age >= 18:
    print("网吧")
    print("恋爱")
    print("prohub")
elif sex == '男':
    print("网吧")
    print("恋爱")
    print("prohub")
else:
    print("一边玩去")  

猜拳游戏

import random

# 随机生成1~3的任意整数
num = random.randint(1, 3)
print(num)
user = int(input("1,石头 2,剪刀 3,布："))
if user == 1:
    if num == 1:
        print("平局")
    if num == 2:
        print("玩家赢了")
    if num == 3:
        print("电脑赢了")
elif user == 2:
    if num == 1:
        print("电脑赢了")
    if num == 2:
        print("平局")
    if num == 3:
        print("玩家赢了")
elif user == 3:
    if num == 1:
        print("玩家赢了")
    if num == 2:
        print("电脑赢了")
    if num == 3:
        print("平局")

循环语句

while 条件:
	条件满足时.运行1
	条件满足时.运行2
	.....省略.....
#选中tab键整体向左平移四个空格，shift+tab键向右平移四个空格还原
import random

while True:
    # 随机生成1~3的任意整数
    num = random.randint(1, 3)
    print(num)
    user = int(input("1,石头 2,剪刀 3,布："))
    if (user == 1 and num == 2) or (user == 2 and num == 3) or (user == 3 and num == 1):
        print("玩家赢了")
    elif user == num:
        print("平局，狗贼再来一局")
    else:
        print("电脑赢了")

for 临时变量 in 列表或字符串等可迭代对象

#第一种方式
for i in "prohub":
    print(i)
#第二种方式，指定循环次数
#默认[0,num)
#[num1,num2)
for i in range(10):
    print(i)
for i in range(2, 10):
    if i == 6:
        continue
    print(i)

字符串下标，切片使用

web = "prohub"
#数组下标
print(web[0])
#数组切片，[0,3)
print(web[0:3])
# 获取整个字符串
print(web[0:6])
print(web[:])
print(web[:6])
print(web[0:])
#如果是负数，输出时则减少对应个数的字符,倒数第几个
print(web[0:-1])#prohu
print(web[0:-2])#proh

# 步长的使用
# 1 如果步长是正的 那么就意味着从起始位置向右走到结束位置
# 2 如果步长是负的 那么就意味着从起始位置向左走到结束位置
# 仍然左闭右开
print(web[5:0:-1])#buhor
print(web[0:6:2])#pou
print(web[0:6:1])#prohub
# 直接倒序
print(web[::-1])

字符串功能函数

# 子字符串查找，如果找到返回对应第一个字母的位置，否则返回-1
print(web.find("hub"))
# 设置查找范围
print(web.find("hub", 0, len(web)))

# index函数使用和find差不多,但是如果str不在web中，直接报错
# print(web.index("111"))

# count函数，统计str在web出现的次数
print(web.count("o"))

# replace函数,可以指定替换次数否则默认全替换。
new_web = web.replace("hub", "yellow", web.count("hub"))
print(new_web)

# split函数,可以指定切割次数
web = "https://cn.pornhub.com/"
web = web.split(".", web.count(".") - 1)
print(web)  # ['https://cn', 'pornhub', 'com/']

# join函数，可以在字符串上添加新的字符串,每个字符或者每个元素进行插入
# split函数使用之后的字符串，在每个间隔加上对应的符号然后连接起来
web = "https://cn.pornhub.com/"
str = "@"
new_str = str.join(web)
print(new_str)

列表(数组)

# 列表可以存放各种类型的数据，存放多个数据

# 列表的定义
my_list = []
my_list = list()

my_list = [1, 2, 3, 4, 5, 6]
# 列表可以存放不同的数据类型 存放多个数据
my_list = [1, 2, 6, 6.66, "888", [666, 888]]

# 列表的真正使用情况 存放同类数据
# 列表获取值
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
print(web[0])
print(web[1])
print(web[2])
#for循环输出
for i in web:
    print(i)
print(web)
# 添加元素append 在列表的末尾添加元素！！！
web.append("ghs")
print(web)
web.append(["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"])
print(web)
# extend 将两个表融合在一起
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
web.extend(["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"])
print(web)
# insert 在指定位置插入数据,从零开始
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
web.insert(4, "ghs")
print(web)
# 修改
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
web[0] = "ghs"
print(web)
# 查找元素(in,not in,index,count)
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
if "ghs" in web:
    print("together")
else:
    print("go out")
if "ghs" not in web:
    print("go out")
dex = web.index("里番——あねよめカルテット 上巻")
print(dex)
item = web.count("里番——あねよめカルテット 上巻")
print(item)
# 删除元素(del,pop,remove)
web = ["https://cn.pornhub.com/", "https://bc212.com/", "里番——あねよめカルテット 上巻"]
# del
del web[0]
print(web)
# pop
web.pop()
print(web)
# remove
web.remove("https://bc212.com/")
print(web)
# 排序（sort，reverse）
num = [6, 4, 8, 4, 1, 5, 74, 41, 88]
# 默认从小到大排序
num.sort()
print(num)
# 改变排序顺序
num.sort(reverse=True)
print(num)
# reverse排序,逆序排列，只是将元素顺序反转
num.reverse()
print(num)
num = [6, 4, 8, 4, 1, 5, 74, 41, 88]
num.reverse()
print(num)

列表例题

随机将八个老师分配在三个教室里面

import random

classroom = [[], [], []]
teacher = ["a", "b", "c", "d", "e", "f", "g", "h"]
for i in teacher:
    num = random.randint(0, 2)
    classroom[num].append(i)
num = 1
for i in classroom:
    print(f"第{num}教室")
    print(i)
    num += 1

列表推导式

# 列表推导式可以根据公式快速生成列表
# 快速生成[0,4)的列表
a = [x for x in range(4)]
print(a)
# 生成偶数列表
# if语句是嵌套在for循环里面的
a = [x for x in range(100) if x % 2 == 0]
print(a)
# for循环的嵌套关系
# 双重循环，x在外y在里
a = [(x, y) for x in range(66) for y in range(88)]
print(a)


# 使用推导式生成九九乘法表
a = [(x, "*",+y, "=", x * y) for x in range(1, 10) for y in range(x, 10)]
print(a)

元组

# 元组中的消息不能修改,只读属性，添加，排序都不可以
#切片可以因为没改变元组的值，只是读取

# 定义,使用小括号定义
name = (1, 2)
print(type(name))
# 定义方式
name = tuple()
# 定义一个元素的元组
name = (1,)
name = (1, 2, 1, 2, 3, 5)
# index,count
print(name.index(1))
print(name.count(1))
# 元组key可以转化为list和tuple
print(name)  # (1, 2, 1, 2, 3, 5)
name = list(name)
print(name)  # [1, 2, 1, 2, 3, 5]
name = tuple(name)
print(name)

字典（结构体）

字典，元组和列表可以相互转化，字典的key参与转化

# 字典：存储的是某个事物的详细信息
students = [{}, {}, {}, {}]
# 字典：由 key-value 键值对

# 字典的定义
# name={}
# name=dict()
people = {"name": "管超龙", "sex": "man", "age": 20, "weight": 180}
students[0] = people
print(type(people))

# 可以强制转换为元组和列表，但是元组只是存储key值
stu = tuple(people)
print(stu)
stu = list(people)
print(stu)
# 遍历
print(students[0]["name"])
for i in people:
    print(students[0][i])
# 修改元素
people["name"] = "GCL"
print(people["name"])
# 添加元素
people["telephone"] = 19861888888
# 删除元素
del people["name"]
print(people)
# 清空
people.clear()
print(people)

字典的功能函数

web = {"name": "gcl", "tel": "110", "sex": "男"}
# 1 len() 获取字典，元组，集合，字符串，列表长度
length = len(web)
print(length)

# 获取key值
keys = web.keys()
print(keys)
# 获取value值
for i in web:
    print(i, end=" ")
    print(web[i])
# items()获取字典的所有的key-value键值对
for i in web.items():
    print(i)
for x, y in web.items():
    print(x, y)

集合(set)

# 集合最大的特点是没有重复的值并且自动排序
a = set()
print(type(a))
a = {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(type(a))
# 可以通过将列表转化为集合进行去重
b = [1, 1, 1, 2, 6, 5, 5, 5, 6, 6, 6, 9, 5, 5, 8, 9, 9, 9]
b = set(b)
b = list(b)
print(type(b))
print(b)
# 使用字典去除重复值
b = [1, 1, 1, 2, 6, 5, 5, 5, 6, 6, 6, 9, 5, 5, 8, 9, 9, 9]
b=dict.fromkeys(b)
print(b)
print(list(b))
# 使用not in去除重复值
b = [1, 1, 1, 2, 6, 5, 5, 5, 6, 6, 6, 9, 5, 5, 8, 9, 9, 9]
a=[]
for i in b:
    if i not in a:
        a.append(i)
print(a)
# 使用count去除重复值
b = [1, 1, 1, 2, 6, 5, 5, 5, 6, 6, 6, 9, 5, 5, 8, 9, 9, 9]
for i in b:
    while b.count(i)>1:
        b.remove(i)
print(b)

拆包

# 元组支持拆包
a, b = (66, 88)
print(a)
print(b)
# 列表支持拆包
a, b = [1, 2]
print(a)
print(b)
# 字典支持拆包
# 获取的是key值
a, b = {"name": "gcl", "age": 18}
print(a)
print(b)

# 巧用拆包进行数值交换，python特有
print(a)
print(b)
a, b = b, a
print(a)
print(b)

公共方法

函数

# define 定义函数
# def 函数名(...):
#     功能代码
# 调用函数
# 函数名(...)
def func(s):
    """
    程序员
    打油诗
    :param s:随意体验
    :return:无返回
    """
    print("写字楼里写字间，写字间里程序员;")
    print("程序人员写程序，又拿程序换酒钱;")
    print("酒醒只在网上坐，酒醉还来网下眠;")
    print("酒醒酒醉日复日，网上网下年复年;")
    print("但愿老死电脑间，不愿鞠躬老板前;")
    print("奔驰宝马贵者去，公交自行程序员;")
    print("别人笑我忒疯癫，我笑自己命太贱;")
    print("不见满街漂亮妹，哪个归得程序员;")


a = "hahahahaha"
func(a)
# 查看文档说明
help(func)
# 查看文档说明
print(func.__doc__)


# return 返回结果，因为python对于变量的方便性所以可以随便返回和接收。
# 默认返回None
def add(a, b):
    return a + b


num = func(a)
print(num)
print(add(100, 200))

# 还可以使用变量存储函数地址然后调用变量和地址的作用一样
num=func
num(a)

匿名函数

# 正常的定义函数方式
def add_func(a, b):
    return a + b


# 匿名函数
# lambda 参数:表达式
lambda a, b: a + b
num = lambda a, b: a + b
print(num(10, 20))


# 匿名函数注意点
# 匿名函数不能使用if语句，while循环，for循环，只能编写单行的表达式或者函数调用，普通函数都可以
# 匿名函数中返回结果不需要使用return，表达式的运行结果就是返回结果，普通函数返回结果必须return
# 匿名函数也可以不返回结果，例如：lambda: print('hello world')


# 匿名函数的应用
def function(func):
    a = 666
    b = 888
    print(func(a, b))


# 可以根据需要传递对应的函数给功能函数使用，可以快速定义函数，不需要起名字
function(lambda a, b: a + b)
function(lambda a, b: a - b)

递归函数

递归函数解决求n的阶乘

n = int(input("输入n："))
sum = 1


# 解法一
def func(n):
    if n == 0:
        return
    else:
        # 函数内要使用全局变量需要提前声明
        global sum
        sum *= n
        n -= 1
        func(n)


func(n)
print(sum)


# 解法二
def func1(n):
    if n == 1:
        return 1
    else:
        result = n * func1(n - 1)
    return result


print(func1(n))

多值参数

# 1 缺省参数
# 定义的时候缺省参数要放在最右边,防止出现错误赋值（将下一个参数的值付给了缺省参数）和参数个数不匹配问题
def func(name, age=18):
    print(name)
    print(age)


func("龟叔")
func("马冬梅", 20)


# 2 不定长参数
# 应用在参数发生多余的情况
# *args:接收多余的单值参数(list,tuple,dict)，元祖方式接受
# **kwargs:接收多余的键值对参数，字典的方式接受
def func1(name, age, *args, **kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)


# 测试args
func1("gcl", 20, 18, 45, 46, 4896, [112, 65464], (42445454,), {"name": "gcl", })
# 测试kwargs
func1("gcl", 66, 5, 5, 4, 54, tel=110, na="gcl")


# 缺省参数可以在*args的后面,可以在kwargs前面
# 顺序不一样可能导致缺省参数一直使用默认的数值
def sum_num(a, b=66, c=88, *args, **kwargs):
    print(a)
    print(args)
    print(b)
    print(c)
    print(kwargs)


sum_num(66, 457, 789, 5765, 57587, 5785, 5875, 758)

局部变量和全局变量

web = "prohub"


# 局部变量，定义在函数里面的变量
# 使用id查看变量的地址编号，对于地址都有编号，来体现区别
def func():
    web = "github"
    print(web)
    print("局部变量", id(web))


func()
print(web)
print("全局变量", id(web))
print("@" * 30)


# 在函数内部修改全局变量
def func1():
    global web
    web = "github"
    print("函数内部", web)


func1()
print("函数外部", web)

# 此处的id编号和上面局部变量的id编号相同
# 因为值一样，而值的地址不变，所以一样
# 此概念类似java的string赋值常量
print("地址编号为", id(web))

return返回值

def func():
    a = 66
    b = 88
    c = 99
    print(id(a))
    return a, b, c
    # return [1, 2, 3]
    # return {}
    # return 10


num = func()
# 返回多个值且没指定类型时，默认返回值是元组
print(type(num))
# 拆包技巧
a, b, c = num
# 存储的值一样那么地址编号就一样，因为常量开辟出来一个固定的空间地址然后编号，进行地址赋值
# 由于常量不能被修改，因此地址也不会改变，所以可以直接使用对应的地址进行赋值且不会出错
print(id(a))
d = a + c
e = a + c
# 同理
print(id(e))
print(id(d))
# 此法也适用于局部变量和全局变量

引用

可参考java中的string变量的常量池概念

# 列表变量实际上是存储的地址，因此指针指向地址的内容变了，都会变。
web = ["prohub"]
html = web
html.append("github")
web = {"name": "gcl", "age": "18"}
html = web
print("元组")
web["sex"] = "男"
print(html)
# 在相同的地址上扩展了存储内容，所以地址编号相同，并且值也相同
# 如果赋值后地址一样会导致一改全改，出现错误。
print(id(html))
print(id(web))
print(web)
print(html)
# 重新赋值会改变地址
html = ["prohub"]
print(id(html))
# 但是对于常量不可变类型，赋值是不会改变地址的
# 因为常量不可变，所以赋值后地址是一样的
# 元组
print("元组")
html = (123,)
web = (123,)
print(id(web))
print(id(html))
# 常熟
print("常数")
html = 666
web = 666
print(id(html))
print(id(web))
# 字符串
# 其实字符串是可变的，但是为了实现功能，有对应的完善所以可以随意赋值使用
print("字符串")
web = "prohub"
html = "prohub"
print(id(web))
print(id(html))
# 比如这样虽然内容一样，但是地址不同，不会出现改一个牵连都改的情况
a = "456"
c = "456"
c += "2"
c = "4"
b = c + "56"
print(id(a))
print(id(c))

函数中的引用

# 引用在函数中的使用,输出都相等
def func(a):
    a.append(456)


a = [123]
func(a)
print(a)

a = "123"


def test(a):
    a += a
    # +=类似append或extend操作，在原有地址上操作，值都一起改变
    print(a)
    a = a + a
    # 坑点
    # 这样值就不一样了，相当于产生新地址进行赋值,不会改变全局变量
    print(a)


test(a)
print(a)