本文介绍了Python编程的基础概念，包括print与input函数、数据类型与运算符、列表、元组、字典、集合、选择结构、循环结构、函数、参数、返回值、文件读写、JSON处理以及CSV数据格式。此外，还涉及类和继承的概念。
(life is short,you need python)
一.print 与 input 函数
print("hello world")
print(1)
print(1+2)
print("this is"+str(123))
print("1+2")//字符输出
#format格式化输出
print("Name:{} age{}",format("str",16))
num = input()
print(num)
num = input("please inout your number")
print("你的输入是：" + num)
num = int(input("请输入一个整数：")) //强制类型转换
print(num+5)
二.数据类型，运算符
数据类型包括：整型，浮点型，字符串（字符串包含引号，可以用 ‘\’ 来转义）print(" n\"ih\"ao ") 如此，布尔值，空值（None），类型转换
a = 5 print(type(a)) a = str(a) print(type(a))
变量的命名规则：
1.变量名必须只能包含数字、字母和下划线，而且不能以数字开头 2.变量名区分大小写。A1与a1是不一样的 2.变量名不能和跟python关键字一样
运算符：
# 逻辑运算符号：and or not
print((1 > 2) and (3 > 2))
print((1 > 2) or (3 > 2))
print(not(3 > 2))
print('\n')
# 成员运算符 in 和 not in
print('a' in 'abc')
print('a' not in 'abc')
# 身份运算符 is / is not 比较两个对象的储存单元
三.列表与元素
my_list = ["666", 1, 2, 3, 1.24, 'abd', False, "haohaohao"]
print(my_list)
# 列表中元素的相关操作
print("第一个元素是："+my_list[0])
print("最后一个元素:"+my_list[-1])
# len() 返回长度
print("最后一个元素:"+my_list[len(my_list)-1])
# print("倒数第二个元素"+my_list[len(my_list)-2])
# print("倒数第二个元素"+my_list[-2]) 倒数第二个元素为bool值，不可以被访问
# 修改元素的值
my_list[-2] = "ddd"
print("倒数第二个元素"+my_list[-2])
# 2.增加元素 （1） append()
my_list.append(666)
print(my_list)
# (2) extend() 列表后面追加列表
my_list2=[1, 2, 3, 4]
my_list.extend(my_list2)
print(my_list)
# （3）insert() 在指定位置插入元素
my_list.insert(1, "hello")
print(my_list)
# 删除元素 （1）pop() 会返回被删除的元素值
my_list.pop(1)
print(my_list)
# （2）del
del my_list[1]
print(my_list)
# (3) remove() 删除与参数匹配的元素，没有返回值
my_list.remove(2)
print(my_list)
# 查询元素
my_list_test=[1, 2, 3, 4, 5]
print( my_list_test[2])
print(my_list_test[2:4]) # 左闭右开的区间
print(my_list_test[1:]) # 第二个到最后一个
print(my_list_test[:3]) # 第四个以前的所有元素
print(my_list_test[:]) # 全部元素
print(max(my_list_test))
print(min(my_list_test))
# list.count(obj) 返回某个元素在列表中出现的次数
# len（list） 列表的长度
四.元组，字典，集合
元组与列表最大的区别：元组的元素不能够被修改（元组只能查，其他操作均不可以）
my_tuple =("java", "CPP", "C", "python", 1,2,3,4)
print(my_tuple)
print(my_tuple[0],my_tuple[-1],my_tuple[-2])
print(my_tuple[:])
print(my_tuple[1:5])
print(my_tuple[:5])
print(my_tuple[1:])
print(len(my_tuple))
print(my_tuple.count("python"))
字典，用花括号表示，里面的元素由键，和值两部分组成，称为键值对。
键值对在字典里是没有顺序的，执行效率比列表和元组要高，但占用内存更大，可以通过键来访问某个值。
dictionary = {'str': 'str_value', 1.1: 1.1, 5: 'int_value', True: 'true_value'}
print(dictionary)
print(dictionary['str'])
print(1.1)
print(dictionary["str"])
print(dictionary[5])
print(dictionary[True])
1、键的类型只能是常量类型（即值是固定不变的，如数字、字符串等） 2、键是唯一的，即不能重复，但是值可以重复
集合：（Set）一种复合类型，无序并唯一地存放容器元素类型。用set（）方法创建，但集合却只有键没有值，并且键不能重复并且无序。集合有并，差，交，补，判断子集的操作。
set1 = set([1,2,3]) set2 = set([2,3,4,5]) set3 = set([2,5]) \# 集合求并 print(set1|set2) \# 集合求差 print(set1-set2) print(set2-set1) \# 集合求交 print(set1 & set2) \# 集合求补 print(set1^set2) \#是否为子集 print(set1<=set2) print(set3<=set2) print(set2>=set3) print( set2> set3)
五.选择结构与循环结构
-
if elif else
-
for循环
-
list1 = [1,1,2,3,4,5] for i in list1: print(i) for j in range(10): print(j) a = 8 while a < 10: print(a) a += 1
六.函数，参数，返回值
（Function）
def 函数名(参数):
#（注意缩进）
函数体
return 返回值
def my_function():
print("好好好")
my_function()
my_function()
my_function()
def sayHello (a):
j=0
while j<5:
print(a)
j+=1
sayHello('hello world')
sayHello("nihao")
\# sayHello()
def my_fun(a=1, b=2):
print(a)
print(b)
my_fun(b=4, a=3) # 先输出3，再输出4
my_fun(4,3)
def add(a,b): c = a+b return c d=add(1,2) print(d) def factorial(a): if a<=1: s=1 • else: • s=a*factorial(a-1) • return s print(factorial(6)) print(factorial(1))
七.文件读写，JSON，CSV
一.读写
1.保存文件
text ="this is two text"
f = open("..\\text.txt","w",encoding= "utf-8")
f.write(text)
f.write("\no over")
f.close()
text ="this is a text"
with open("test.txt","w",encoding="utf-8") as f:
f.write(text)
# 可以避免因为出错或者其他原因不能close（）文件的情况
关于open()函数的三个参数
（1）文件名。可以指定绝对路径，若不写路径则保存在该.py文件所在目录 （2）操作模式。操作模式有很多，常用的有w、a、r、wb、rb等
（3）编码。常用编码有utf-8、gbk等，编码问题可以会导致乱码
2.读取文件
f = open("test.txt", "r", encoding="utf-8")
content = f.read()
print(content)
f.close()
with open("test.txt","r",encoding="utf-8") as f:
print(f.read())
with open("test.txt","r",encoding="utf-8" ) as f:
print(f.readline())
for line in f.readlines():
print(line)
1、f.read()，一次性读取所有内容，若文件很大可能会导致内存不够用，故可以指定一个参数（每次读写的大小），比如说f.read(1024) 2、f.readline()，只能读取一行 3、f.readlines()，读取所有行，返回一个列表
二.JSON
json数据的格式可以是：
`{"name":"admin","age":18}`
也可以是：
`["hello",3.1415,"json"]`
还可以是：
`[{"name":"admin","age":18},{"name":"root","age":16},{"name":"张三","age":20}]`
# json.dumps（）将列表或者字典转换成JSON字符串
import json
jsonData = [{"name": "李奎", "age": 20}, {"name": "韩苗", "age": 21}, {"name": "柳文", "age": 22}]
json = json.dumps(jsonData, ensure_ascii=False) # 第二个参数使保持中文字符
print(json)
\# json.dump（） 保存JSON数据到本地文件
import json
jsonData = [{"name": "李逵", "age": 20}, {"name": "韩苗", "age": 21}, {"name": "柳文", "age": 22}]
with open("test.json", "w", encoding="utf-8") as fp:
json.dump(jsonData, fp, ensure_ascii=False)
\# 将JSON字符串加载为列表对象
import json
json_str = '[{"name": "云天河", "age": 20}, {"name": "韩菱纱", "age": 21}, {"name": "柳梦璃", "age": 22}]'
jsonData = json.loads(json_str)
print(type(json_str))
print(type(jsonData))
\# 从文件中读取json
import json
with open("test.json", "r", encoding="utf-8") as fp:
json_str = json.load(fp)
print(json_str)
三.CSV
CSV（Comma-Separated Values，逗号分隔的值）是一种简单、实用的文件格式，用于存储和表示包括文本、数值等各种类型的数据。CSV 文件通常以 .csv 作为文件扩展名。这种文件格式的一个显著特点是：文件内的数据以逗号 , 分隔，呈现一个表格形式。CSV 文件已广泛应用于存储、传输和编辑数据。
import csv
header = ['姓名', '年龄', '性别']
values = [
('李奎', '18', '男'),
('韩苗', '17', '女'),
('柳文', '20', '女')
]
with open("test.csv", "w",newline="") as fp: # 若不加newline=""则会出现空行
writer = csv.writer(fp)
writer.writerow(header)
writer.writerows(values)
import csv
with open("test.csv", "r") as fp:
reader = csv.reader(fp)
for x in reader:
print(x)
八.类，类方法，继承
类（Class）是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
class human:
name = "somebody"
age = 16
def say(self): # 类方法，所有的类方法都至少有一个参数self
print("your monther")
def think(self,str="who"):
print("play with"+str)
man =human()
print(man.age)
print(man.name)
man.say()
man.think(" you")
class human: # 定义一个类
def __init__(self,name="someone",age=20): # 此方法自动执行，用于初始化（如果之后补不赋值也可以，如果最开始没有初始化，则创造实例时候必须赋值）
self.name = name # 类属性name
self.age = age; # 类属性age
def say(self): # 类方法，所有的类方法都至少有一个参数self
print("hello")
def think(self,a=1,b=2):
print(a+b)
human1 = human() # 实例化human类，得到对象human1
print(human1.name) # 访问对象的name属性
human1.say() # 调用对象的say()方法
human1.think(a=2,b=3) # 调用对象的think()方法，并且传入参数
1.参数
类里所有的方法都至少有一个参数self（或者this），其他的与普通方法无区别
2.专有方法
__init__ : 构造函数，在生成对象时调用 __del__ : 析构函数，释放对象时使用 __repr__ : 打印，转换 __setitem__ : 按照索引赋值 __getitem__: 按照索引获取值 __len__: 获得长度 __cmp__: 比较运算 __call__: 函数调用 __add__: 加运算 __sub__: 减运算 __mul__: 乘运算 __truediv__: 除运算 __mod__: 求余运算 __pow__: 乘方
3.私有属性和私有方法
在一个类里定义属性或者方法的时候，若以双下划线开头，声明是私有属性或方法，不能在类的外部被使用或直接访问
class human:
def __init__(self,name="somebody",age=18):
self.name =name
self.age =age
def say(self):
print("hello")
def think(self,a,b):
print(a+b)
class student(human):
def __init__(self,school="dzkd",job="study"):#初始化学生
super().__init__("dh",18) #调用父亲的初始化方法
self.school=school
self.job=job
def think(self,a,b): //c
print(a*b)
\# stu =student("dzke","study")
stu =student()
print(stu.name)
print(stu.school)
print(stu.age)
print(stu.job)
stu.say()
stu.think(2,9)
扫一扫
1128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
