''' print()函数的用法: print('Hello World!') print('Hello', 'World!') # 逗号自动添加默认的分隔符：空格 >>> hello world! print('Hello' + 'World!') # 加号表示字符拼接 >>> helloworld! print('Hellw' + 'World!', sep = '***') # 单词间用***分隔 >>> hello***world print('-' * 10) #'-'重复10遍 print('Hello World!', end = '') #print()最后默认回车，加end = ''表示不回车 ''' ''' print(5 / 2) # 2.5 # /运算一定最后结果一定是浮点数！ print(5 // 2) # 丢弃余数，只保留商 print(5 % 2) # 求余数 print(5 ** 3) # 5 的 3 次方 print(5 > 3) # 返回 True print(3 > 5) # 返回 False print(20 > 10 > 5) # python 支持连续比较 print(20 > 10 and 10 > 5) # 与上面相同含义 print(not 20 > 10) # False ''' ''' number = input("请输入数字：") # input 用于获取键盘输入 print(number) print(type(number)) # input 获得的数据是字符型 print(number + 10) # 报错，不能把字符和数字做运算 print(int(number) + 10) # int 可将字符串 10 转换成数字 10 print(number + str(10)) # str 将 10 转换为字符串后实现字符串拼接 ''' ''' sentence = 'tom\'s pet is a cat' # 单引号中间还有单引号，可以转义 => /' sentence2 = "tom's pet is a cat" # 也可以用双引号包含单引号 sentence3 = "tom said:\"hello world!\"" sentence4 = 'tom said:"hello world"' # 三个连续的单引号或双引号，可以保存输入格式，允许输入多行字符串 words = """ hello world abcd""" print(words) py_str = 'python' len(py_str) # 取长度 py_str[0] # 第一个字符 'python'[0] py_str[-1] # 最后一个字符 # py_str[6] # 错误，下标超出范围 py_str[2:4] # 切片，起始下标包含，结束下标不包含 py_str[2:] # 从下标为 2 的字符取到结尾 py_str[:2] # 从开头取到下标是 2 之前的字符 py_str[:] # 取全部 py_str[::2] # 步长值为 2，默认是 1 py_str[1::2] # 取出 yhn py_str[::-1] # 步长为负，表示自右向左取 提示：切片是左闭右开！ py_str + ' is good' # 简单的拼接到一起 py_str * 3 # 把字符串重复 3 遍 't' in py_str # True 'th' in py_str # True 'to' in py_str # False 'to' not in py_str # True ''' ''' alist = [10, 20, 30, 'bob', 'alice', [1,2,3]] len(alist) alist[-1] # 取出最后一项 alist[-1][-1] # 因为最后一项是列表，列表还可以继续取下标(类似c中的二维数组) [1,2,3][-1] # [1,2,3] 是列表，[-1] 表示列表最后一项 alist[-2][2] # 列表倒数第 2 项是字符串，再取出字符下标为 2 的字符 alist[3:5] # ['bob', 'alice'] (列表也可以切片) 10 in alist # True 'o' in alist # False 100 not in alist # True alist[-1] = 100 # 修改最后一项的值 alist.append(200) # 向列表中最后追加一项 ''' ''' atuple = (10, 20, 30, 'bob', 'alice', [1,2,3]) len(atuple) 10 in atuple atuple[2] atuple[3:5] # atuple[-1] = 100 # 错误，元组是不可变的 ''' ''' # 字典是 key-value（键－值）对形式的，没有顺序，通过键取出值 adict = {'name': 'bob', 'age': 23} len(adict) 'bob' in adict # False 'name' in adict # True adict['email'] = 'bob@tedu.cn' # 字典中没有 key，则添加新项目 adict['age'] = 25 # 字典中已有 key，修改对应的 value ''' ''' if 3 > 0: print('yes') print('ok') if 10 in [10, 20, 30]: print('ok') if -0.0: print('yes') # 任何值为 0 的数字都是 False if [1, 2]: print('yes') # 非空对象都是 True if ' ': print('yes') # 空格字符也是字符，条件为 True ''' ''' a = 10 b = 20 if a < b: smaller = a else: smaller = b print(smaller) s = a if a < b else b # 和上面的 if-else 语句等价 print(s) ''' """ python导入模块 语法：import 模块一，模块二，模块三...... eg: import pygame """ """ 调用模块中的内容： 语法：模块.函数 or 模块.变量 eg:pygame.init() """ """ 若不存在同名函数则有更方便的写法： from pygame import init init() """ """ 注释： 单行注释：# 多行注释：""" """ """ """ 缩进： 利用Tab或空格键控制（不可混用） 一般使用四个空格表示一级缩进 """ """ 语句换行： 在语句外侧添加一对圆括号实现长语句的换行 eg：string = ("asdasasdasdasdasdasdasd" "asdasdasdasasdasdasdas" "asdasdasdasdasdasdasda" "asdasdasdasdasdasdasdas") 值得注意的是：若语句原本就用圆括号or中括号or大括号包裹，则无需额外添加圆括号 """ """ 关键字： 查看python中的关键字： import keyword print(keyword.kwlist) 查看关键字的声明： print(help("关键字")) """ """ 数字类型： 整型(int) : 0 101 -239 浮点型(float): 3.1415 4.2E-10 -2.334E-9 复数(complex): 3.12 + 1.2.3j 布尔(bool): True Flase """ """ 字符串： 'python' "python" '''python''' """ """ 列表：可以保存任意数量，任意类型的元素，可以被修改，使用[]创建列表 eg:[1, 2, 'python'] #这是一个列表 """ """ 元组：可以保存任意数量，任意类型的元素，但是不可以被修改，使用()创建元组 eg:(1, 2, 'python') #这是一个元组 """ """ 集合：可以保存任意数量，任意类型的元素，要注意集合中的元素无序且唯一,使用{}创建集合 eg:{'apple', 'orange', 1} """ """ 字典: 键 ：值 形式的键值对，键不可重复，使用{}创建字典 eg:{"name:wj", "age:18"} """ """ 查看变量的类型： type(变量名） """ """ 变量的输入输出： 1.input()函数： name = input("请输入您的姓名: ") 2.print()函数： print(*objects, sep = ' ', end = '\n', file = sys.stdout) object:输出的对象 sep:分隔符，默认为空格 end:结尾，默认为换行符 file：表示输出的文件对象 eg:print(string_1, string_2, string_3) """ """ 整数型(int) 长度没有限制 二进制：0b(0B) bin(x) 八进制：0o(0O) oct(x) 十六进制：0x(0X) hex(x) """ """ 浮点型(float) 表示实数(整数部分+小数点+小数部分) 取值范围为-1.8e308 ~ 1.8e308(超出范围默认为inf or -inf) 双精度，每个浮点型数据占据8个字节 科学计数法: eg：-314 => -3.14e2 0.00314 => 3.14e-3 """ """ 复数型(complex) 实部+虚部 complex_1 = 1 + 2j conplex_2 = 3j print(complex_1.real) #获取实部 print(complex_2.imag) #获取虚部 """ """ 布尔型(bool) True = 1, False = 0 False = 1.None, 任何数字类型的0(0, 03.0, 0j) 2.任何空序列('''', (), []) 3.空字典 检测数据的bool值：print(bool(检测数据)) """ """ 强制类型转换： int(x) 浮点数转换为整数类型时只保留整数部分 float(x) complex(x) """ """ 算术运算符： a / b = 两数的商，除数不能为0，结果为浮点型 a // b = 获取两数的商的整数部分 a ** b = a的b次幂 值得注意的是进行不同数值的混合运算时python会强制对数值的类型进行临时类型转换： 1.整数与浮点数：将整数转换为浮点数 2.其他与复数：将其他转换为复数 eg:print(10 / 2.0) => 5.0 print(10 - (3 + 5j)) => 7 - 5j """ """ 海象运算符：=: eg: a = 1 res = a + (b := 2) print(res) => 3 """ """ 逻辑运算符：双目：and，or 单目：not x and y : 两个操作数的bool值均为True ：结果为y x or y : 两个草操作数的bool值均为True : 结果为x not x : x = False 结果为Ture """ """ 成员运算符： in:如果指定元素在序列中返回Ture not in：如果指定元素在序列中返回Flase """ """ 位运算: << : 操作数 * 2^n(将二进制数所有位全部左移n位，高位丢弃，低位补0) >> : 操作数 / 2^n(将二进制数所有位全部左移n位，低位丢弃，高位补0) &(按位与) : 对应位均为1时结果位为1 |(按位或) ：对应位有一个1时结果位为1 ^(按位异或) ：对应位相同结果位为0 ~(按位取反) ： 1变0， 0变1 技巧：使用位运算时多加括号 """ """ if_elif语句： if month in [1, 3, 5, 7, 8, 10, 12]: print(......) elif month in [4, 6, 9, 11]: print(......) elif month == 2: if year % 400 == 0 or year % 4 == 0 and year % 100 != 0: print(.....) else: print(.....) """ """ for 语句: for 临时变量 in 目标对象： 代码段 eg: for word in "python" print(word) """ """ 转义字符：\ 1.\ + 引号：引号不参与配对 2.\b:退格 3.\v:纵向制表符 4.\t:横向制表符 5.\r:回车 值得注意的是：当字符串中出现多个转义字符但又不希望转义字符起作用： 可以在字符串引号之前添加r或R，是字符串退化为原始字符串 eg:print(r'.....') """ """ 使用%格式化字符串： 语法：字符串（包含格式符）% 真实数据 格式符：%c : 字符 %s : 字符串 %d : 整数 %u ：无符号整型 %o ：无符号八进制数 %x ：无符号十六进制数 %f ：浮点数（默认保留6位） eg: print("字符串" % 变量名) print("字符串" % (变量名1, 变量名2)) """ """ format格式化字符串： 语法：1.print("xxx{}xxx".format(变量名)) 无需关注替换数据的类型 print("xxx{}xxx{}xxx".format(变量名1,变量名2)) 2. print("xxx{1}xxx{0}xxx".format(变量名1,变量名2)) 通过索引匹配 3.指定浮点数精度： print('xxx{:.2%}'.format(变量名)) """ """ 字符串查找find(): str.find(sub[, start[, end]]) sub:指定要查找的子串 start:开始索引，默认为0 end ：结束索引，默认为字符串长度 eg: word = 't' string = 'python' res = string.find(word) print(res) => 2 """ """ 字符串替换replace(): 语法:str.replace(old, new[, count]) 1.不指定替换次数（全部替换）： string = "xxxxaxxaxx" new_string = string.replace("a", "A") print(new_string) => "xxxxAxxAxx" 2.指定替换次数： string = "xxxxaxxaxx" new_string = string.replace("a", "A", 1) print(nes_replace) => "xxxxAxxaxx" """ """ 字符串分割split(): 语法:str.split(sep = None, maxsplit = -1) sep = 分隔符，默认为空格 maxplit = 分割次数，默认为-1,表示不限次数 eg: string = "xx xax xex xexxa xx" print(string.split()) => ["xx", "xax", "xex", "xexxa", "xx"] print(string.split('e')) => ["xx xax x", "x x", "xxa xx"] print(string.split('a', 1)) => ["xx x", "x xex xexxa xx"] """ """ 字符串拼接 join(): 语法：str.join(iterable) iterable = 链接字符串的字符 eg:string = "python" symbol = "*" print(symbol.join(string)) => p*y*t*h*o*n eg :start = "pyt" end = "hon: print(start + end) => "python" """ """ 删除字符串的指定字符： 1.str.strip([char]) 移除字符串头部和尾部的字符 2.str.lstip([char]) 移除字符串头部的字符 3.str.rstrip([char]) 移除字符串尾部的字符 """ """ 字符串转换大小写： 1.new_string = string.upper()：将字符串的小写字母转换为大写字母 2.new_string = string.lower(): 将字符串的大写字母转换为小写字母 3.new_string = string.capitalize(): 将字符串的首字母转换为大写形式 4.new_string = string.title(): 将字符串的每个单词的首字母变为大写形式 """ """ 字符串对齐： 1.new_string = string.center(13, '-') 长度为13，居中对齐，用-补全 2.new_string = string.ljust(13, '*') 长度为13，左对齐， 用*补全 3.new_string = string.rjust(13, '%') 长度为13，右对齐，用&补全 """ """ 列表: 1.创建列表: list = [] 可以存储整型，浮点型，字符串，列表，元组，字典，还可以是自定义类型 元素可以相同也可以不同 用，分隔 li_1 = list(1) #int类型为不可迭代对象，故创建列表失败 li_1 = list('python') 字符串类型是可迭代类型 li_1 = list([1, 'python']) 列表类型是可迭代类型 （可以通过for ... in ... 语句获取数据的类型是可迭代类型） 2.访问列表元素：1. list[n]访问索引为n的元素，n可以是负数 2. list[start: end: step] print(li_one[1: 4: 2]) => 按步长2获取索引1~4的元素 print(li_one[2:]) => 获取索引2~末尾的元素 print(li_one[:3]) => 获取索引0~3的元素 print(li_one[:]) => 获取列表中所有的元素 3.循环访问元素：for i in li_one: print(i, end = ' ') 3.添加列表元素：1.list.append(x) 在列表末尾加入x 2.list_one.extend(list.two) 一次性将list_two插入到list_one后 3.list.insert(0, "a") 将a插入到列表的索引为2的位置 4.元素排序：1.sort(key = None, reverse = False) 不生成新列表 key = 为指定的排序规则，默认为None reverse = True 时为降序排序，默认为Flase升序排列 eg: list.sort()升序排列 list.sort(reverse = True) 降序排列 list.sort(key = len) 按元素长度排序 2.new_list = sorted(list) 生成升序新列表 3.list.reverse() 逆置列表 5.删除列表元素：1.del list[n] #删除列表中索引为n的元素 del list #删除列表list 2.list.remove('e') #删除列表lis中的'e'元素（若有多个匹配元素，删除第一个） 3.list.pop() #删除列表最后一个元素 list.pop(1) #删除索引为1的元素 4.list.clear() #清空列表 6.列表推导式：1. [运算 for x in list] eg：ls = [1, 2, 3] ls = [date * date for date in ls] #将列表中每一个元素替换为它的平方 2.带有if的推导式 [运算 for x in list if 条件] eg：ls = [date for date in ls if date > 4] #保留列表中大于4的元素 3.带有for的推导式 [运算 for x in ls_1 for y in ls_2] #从左到右依次为外层循环和内层循环 eg: new_ls = [x + y for x in ls_1 for y in ls_2] #生成元素为两列表元素之和的新列表 4.带有for和if嵌套的推导式： [运算 for x in list_1 [if 条件] for y in list_2 [if 条件] for z in list_3 [if 条件] .......................]] """ """ 元组：元组中元素的类型与个数不受限制, 但元组时不可变类型，元素不支持修改，添加，排序，删除等操作 1.创建元组: t1 = () t2 = (1,) #创建单个元素的元组（其中，不可省略） t3 = (1, 2, 3) t4 = (1, 'c', ('e', 2)) #元组嵌套 t1 = tuple() #使用内置函数创建空元组 t2 = tuple([1, 2, 3]) #利用列表创建元组 t3 = tuple('python') #利用字符串创建元组 t4 = tuple(range(5)) => (0, 1, 2, 3, 4) 2.访问元组: print(t[1]) print(t[2:5]) for date in t3: print(date, end = ' '） """ """ 集合：其中的元素无序但是唯一 1.集合的创建：s1 = {1} s2 = {1, 'b', (2, 5)} s = set() #创建空集合 s = {} #此操作是创建空字典！ s = set(可迭代对象) s = set([1, 2, 3]) s = set((2, 3, 4)) s = set('python') s = set(range(5)) #传入整数列表 2.修改元素：1.add(x) #添加元素x，若已存在则忽略 2.remove(x) #删除元素x，若不存在则抛出KeyError异常 3.discard(x) #删除元素x，若不存在则忽略 4.pop() #随机返回集合中的一个元素并删除，若集合为空则抛出KeyError 5.clear() #清空 6.copy() #复制集合，返回值为集合 7.isdisjoint(s2) #判断集合中是否存在与集合s2相同的元素，没有返回True 3.集合推导式：与列表推导式语法结构相同 """ """ 字典: 字典的值可以是任意类型，但键不能是列表或字典类型，字典元素无序，键/值唯一 1.创建字典：d1 = {} d2 = {'A': '123', 'B': '135', 'C': '680'} d3 = dict() d5 = dict({'A': '123', 'B': '135'}) 2.访问字典：1.字典变量[键] 2.字典变量.get(键) 3.dic.key() #返回所有的键 4.dic.values() #返回所有的值 5.dic.items() #返回所有元素 3.字典元素的添加和修改 1.dic[键] = 值 2.dic.update(键 = 值) 当键为不存在的键时，可以实现键值对的添加 4.字典元素的删除 1.dic.pop(指定键) => 删除该键值对，返回对应的值 2.dic.popitem() #删除随机键值对，返回被删除的键值对 3.dic.clear() #清空字典 5.字典推导式：参考列表 """ """ 运算符：1.字符串，列表，元组均支持 “ + ” ，组合数据类型的相加是进行数据的拼接 2.字符串，列表，元组均支持 “ * ” ，组合数据类型的相乘是原数据整数倍的拼接 eg：list = [1, 2, 3] print(list * 3) ==> [1, 2, 3, 1, 2, 3, 1, 2, 3] 3.成员运算符：字符串，列表，元组，集合，字典都支持in / not in """ """ 函数： 1.函数的定义：def 函数名 ([参数列表]): 函数体 [return 语句] 2.函数的调用：函数可以在内部调用其他函数，定义时可以在其内部嵌套定义 eg: def add_modify(a, b): res = a + b print(res) def test(): print("666") test() #注意函数外部无法直接调用内层函数，只能在外层函数中调用内层函数 add_modify(10, 20) 3.函数的参数传递：定义时的参数为形参，传入的为实参 1.位置传递 2.关键字参数 eg: def fun(a, b): ....... return 调用：fun(a = 1, b = 'a') 3.默认参数的传递：定义时可以赋给参数默认值 4.参数的打包与解包 1.打包：函数支持将实参以打包和解包的形式传递参数 形参的前面加上* ==> 以元组的形式打包多个值 加上** ==> 以字典的形式打包多个值 2.解包：在形参前面加一个*将元组解包传入函数 .............**将字典中的值传入函数 5.混合传递：优先级：位置参数传递 > 按关键字参数传递 > 按默认参数传递 > 按打包传递 规则: 从前到后：普通参数 待默认值 *参数 **参数 eg:def test(a, b, c = 33, *temp, **emp) ....... 4.函数的返回值： 1.单个返回值 2.多个返回值：如果函数返回多个返回值：这些值将会保存到元组中 return x, y """ """ 变量作用域：1.函数外部无法访问局部变量，不同函数可以包含同名的局部变量，他们相互独立互不影响 2.值得注意的是：全局变量在函数内部只可以被访问不可以被修改 3.global关键字可以将局部变量声明为全局变量：global 变量 4.nonlocal关键字可以在局部作用域中修改嵌套作用域中的变量 """ """ 匿名函数:是一类无需定义标识符的函数: lambda<形参列表>: <表达式> 其函数体只能是一个表达式，功能简单，不能被其他程序所使用 """ """ 文件：1.文件的基础操作： 1.文件的打开与关闭： 1.打开：open(file, mode = 'r', endcoding = None) encoding用于指定文件的编码格式 mode用于设置文件的打开模式 r ：用只读的方式打开文件，参数为mode的默认值 w ：以只写的方式打开文件，若文件存在，重写文件，否则追加文件 a : 以追加的形式打开文件,只允许在文件末尾追加数据，若文件不存在，创建新文件 r/rb:(只读模式)打开文本文件/二进制文件，若不存在打开失败 w/wb:(只写模式).....................，......创建新文件 a/ab:(追加模式)......................只允许在文件末尾追加数据......创建新文件 r+/rb+:(读取模式)................................... w+/wb+:(读写模式)................................... a+/ab+:(更新模式)................................... 2.关闭： 1.close()方法：file.close() 2.with语句(常用): 使用with语句实现文件的自动关闭 with open('a.txt') as f: pass 2.文件的读写： 1.read()方法可以从指定文件中读取指定字节的数据 eg：read(n = -1) #参数n用于指定读取的字节数，若未指定或n = -1则读取文件中所有内容 with open('file.txt', mode = 'r') as f: print(f.read(2)) #读取两个字节的数据 print(f.read()) #读取剩余全部数据 2.readline():从指定文件中读取一行数据 eg：with open('file.txt', mode = 'r', encoding = 'utf-8') as f: print(f.readline()) print(f.readline()) ..... 3.readlines(hint = -1):一次性读取所有数据，若读取成功返回一个列表，文件中的每一行对应列表中的每一个元素 其中hint控制读取的行数 eg:with open('file.txt, mode = 'r', encoding = 'utf-8') as f: print(f.readline()) 4.推荐的读取方法：为了保证读取安全，推荐多次调用read()方法每次读取n个字节的数据 3.文件的写入： """
04-22
286
286
04-20
03-30
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
