【python基础和anaconda基础学习2】

最新推荐文章于 2024-05-01 18:44:59 发布

Raphael9900

最新推荐文章于 2024-05-01 18:44:59 发布

阅读量806

点赞数

文章标签： python

本文链接：https://blog.csdn.net/Raphael9900/article/details/128001805

版权

一、python基础

1、初级知识

（1）print()打印函数

print语句通常用于输出变量。
为了组合文本和变量，Python 使用 +字符

(可以使用单引号或双引号来声明字符串变量)

print( "Hello, World!")或者是print('hi')

x = "x"

print( "print" + x)

（2）缩进

":"标记一个新的逻辑层，如：while循环、if分支、函数声明、类定义等等。增加缩进表示进入下一个代码层，减少缩进表示返回上一个代码层。Python可以使用空格或制表符（tab符）标记缩进。缩进量（字符个数）不限。

而空格和tab符通常都以空白形式显示，混用不容易区分，影响代码阅读，增加维护及调试的困难。因此 Python PEP8 编码规范，指导使用4个空格作为缩进。

（3）注释#

单行注释：将需要注释的部分开头用#

多行注释：左键选中需要注释的代码，松开，按：Ctrl+/，即可完成多行注释

（4）获取类型：

x = 5

y = "5"

print(type(x))#<class ‘int’>

print(type(y))#<class ‘str’>

（5）变量名命名

变量名必须以字母或下划线字符开头

变量名不能以数字开头

变量名称只能包含字母数字字符和下划线（Az、0-9 和 _ ）

变量名区分大小写（age、Age和AGE是三个不同的变量）

骆驼法则：除了第一个单词外，每个单词都以大写字母开头

myNameIs = "a"

帕斯卡法则：每个单词都以大写字母开头

MyNameIs = "a"

蛇形法则：每个单词由下划线字符分隔

My_Name_Is = "a"

2、变量

·在 Python 中，当你给它赋值时就会创建变量。Python 没有用于声明变量的命令，变量在第一次为其赋值时创建。对于同一个变量，赋值类型不同则会发生类型的变化。如果要指定变量的数据类型，可以通过强制转换来完成。

x = str( 3) # x will be '3'

y = int( 3) # y will be 3

z = float( 3) # z will be 3.0

·变量名区分大小写a=4，A=‘4’，a！=A

·Python 允许您在一行中为多个变量赋值。（确保变量的数量与值的数量相匹配，否则你会得到一个错误。）

x, y, z = "一号", "二号", "三号"

·以在一行中为多个变量分配相同的值,确保变量的数量与值的数量相匹配，否则你会得到一个错误

x = y = z = "菜鸟"

·可以在一行中为多个变量分配相同的值：

x = y = z = "菜鸟"

·还可以使用该+字符将一个变量添加到另一个变量中:

x = "真"

y = "帅"

z = x + y

·对于数字，该+字符用作数学运算符：

x = 6

y = 10

print(x + y)#16

·如果你尝试组合一个字符串和一个数字，Python 会给你一个错误

X=5

Y=“G”

Print(x+y)#wrong

·该怎么修改呢？把数字转为字符即可，则修改为：

X=5

Y=”G”

Print(str(x)+y)#”5G”

·在函数外部创建的变量称为全局变量。无论是在函数内部还是外部，都可以使用全局变量。

x='fsd'
def myf():#注意此处缩进，缩进的都包括是函数里的
x='asd'
print(x)
myf()#输出asd
print(x)#输出fsd

·通常，当您在函数内部创建变量时，该变量是局部的，并且只能在该函数内部使用。要在函数内创建全局变量，可以使用 global关键字。

x='a'
def myf():
    global x
    x='b'
    print(x)

myf()#b
print(x)#b

3、Python数据类型

在 Python 中，数据类型是在为变量赋值时设置的。

（1）置数据类型

文本类型：

str

数字类型：

int, （或 integer，整数类型，可为正负，长度不限）

float, （浮点数，含有小数，可为正负）

Complex（虚数，复数写有“j”作为虚部）

序列类型：

list,

tuple,

range（range函数返回一个range类型的整数序列，一般用在循环结构中。）

映射类型：

dict

套装类型：

set,

frozenset

布尔类型：

bool

二进制类型：

bytes,

bytearray,

memoryview

可使用以下type()函数获取任何对象的数据类型：

X=6

Print(type(x))#<class=’int’>

(2)设置特定数据类型

强调

x = str( "Hello World")

x = int(20)

x = complex(1j)#复数

x =5j
y=6
z=3j

print(x)
print(y+x)
print(z+x)

(6+5j)

x = set(("apple", "banana", "cherry"))#集合

x = frozenset(("apple", "banana", "cherry"))#冻结集

x = bool(5)

x = bytes(5)#字节类型

x = bytearray(5)#字节组类型

x = memoryview(bytes(5))#内存试图类型

x = range(6)#范围

x = list(("apple", "banana", "cherry"))#列表

x = ["apple",#列表
"banana",
"cherry"]
print(type(x))

x = tuple(("apple", "banana", "cherry"))#元祖

x = ("apple",#元祖
"banana",
"cherry")

x = dict(name="John", age=36)#字典

x = { "name" : "John", "age" : 36}#字典

x = float(20.5)

x =35e3
y =12E-4
z = -87.7e100

print(x)
print(y)
print(z)

35000.0

0.0012

-8.77e+101

·python 中的转换是使用构造函数完成的：

int() - 从整数文字、浮点文字（通过删除所有小数）或字符串文字（提供字符串表示整数）构造整数

float() - 从整数文字、浮点文字或字符串文字构造浮点数（提供字符串表示浮点数或整数）

str() - 从多种数据类型构造一个字符串，包括字符串、整数文字和浮点文字

·多行字符串

可以使用三个引号（“““xxx”””或者三个单引号’’’ xxx ‘’’）将多行字符串分配给变量：

a = """从前有座山，

山里有座庙
庙里有个小和尚"""
print(a)#输出保留换行空格这里也可以使用三个单引号

从前有座山，

山里有座庙

庙里有个小和尚

（3）字符串类型

·Python 没有字符数据类型，单个字符只是一个长度为 1 的字符串。方括号可用于访问字符串的元素。获取位置 1 处的字符（第一个字符的位置为 0）：

a = "Hello, World!"
print(a[1])

·遍历字符串

b='111'
for x in b:
print(x)

·字符串长度

len()函数返回字符串的长度，注意标点符号和空格也算一个长度：

a ="Hello, World!"
print(len(a))#11

·检查字符串

要检查字符串中是否存在某个短语或字符，我们可以使用关键字 in。

txt = "The best things in life are free!"
print("free" in txt)#true

也可以通过if判断

if "free" in txt:

print( "是的, 'free'存在.")

·判断不存在

txt = "some times"
print("some" not in txt)

if "some" not in txt:

print( "No.")

·切片字符串

可以使用切片语法返回一系列字符。指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。从开始索引开始切片，直到结束索引的前一个字符，不包括结束索引。第一个字符的索引为 0。

b = "Hello, World!"
print(b[2:5])#llo

·从头开始切片（省略开始索引）

print(b[:5])#Hello

·切到最后（省略结束索引）

print(b[2:])

·负索引（从右往左）

使用负索引从字符串末尾开始切片，就是从右往左看，不再是从左往右看。第0位最后的字符，最后一位为开始字符。

print(b[-5:-2])#orl

·小写转大写

upper()方法以大写形式返回字符串：

a = "Hello, World!"
print(a.upper())

HELLO, WORLD!

·大写转小写

lower()方法以小写形式返回字符串：

print(a.lower())

hello, world!

·删除空格

strip()方法从开头或结尾删除任何空格：

a = " Hello, World! "
print(a.lower())
print(a.strip())

hello, world!

Hello, World!

·替换字符串

replace()方法用另一个字符串替换一个字符串.

print(a.replace("H", "J"))

Jello, World!

·拆分字符串

split()方法返回一个列表，其中指定分隔符之间的文本成为列表项。split()如果找到分隔符的实例，该方法会将字符串拆分为子字符串。

print(a.split(","))

[' Hello', ' World! ']

·字符串连接

要连接或组合两个字符串，您可以使用 + 运算符。

a="you"
b=" are"
c=a+b

也可以直接加上字符串”：

d=a+b+” right”

（4）格式化字符串

·format单个传参

不能像这样组合字符串和数字：

age = 20
txt = " 川川今年 " + age
print(txt)

可以通过使用format() 方法来组合字符串和数字！format()方法接受传递的参数，格式化它们，并将它们放在占位符所在的字符串中 {}。

age = 20
txt = "this number is {}"
print(txt.format(age))

this number is 20

·format多个传参

format() 方法接受无限数量的参数，并放置在各自的占位符中：

quantity = 20
itemno = 3000
price = 49.95
myorder = "第一个{}， {} ， {} ."
print(myorder.format(quantity, itemno, price))

第一个20， 3000 ， 49.95 .

可以使用索引号{0}来确保参数放置在正确的占位符中：

quantity = 20
itemno = 3000
price = 49.95
myorder = "第一个{2}， {1} ， {0} ."
print(myorder.format(quantity, itemno, price))

第一个49.95， 3000 ， 20 .

·其他方法

capitalize() 将第一个字符转换为大写

casefold() 将字符串转换为小写

center() 返回一个居中的字符串

count() 返回指定值在字符串中出现的次数

encode() 返回字符串的编码版本

endswith() 如果字符串以指定的值结尾，则返回 true

join() 将可迭代的元素连接到字符串的末尾

find() 在字符串中搜索指定值并返回找到它的位置

format() 初始化字符串中的指定值

index() 在字符串中搜索指定值并返回找到它的位置

(5)随机数

Python 有一个内置模块 random可以用来生成随机数。

import random

# random.random()最基本的随机函数，返回一个[0.0,1.0)之间的随机小数
x = random.random()
# random.uniform(a,b)在指定范围内生成随机小数，两个参数其中a是上限，b是下限。随机数可为[b,a]
y = random.uniform(4, 1)
# random.randint(m,n)用于生成一个指定范围内的整数。随机数可为[n,m]
z = random.randint(1, 10)
# random.choice(sequence)从序列中获取一个随机元素,list, tuple, 字符串都属于sequence。
L = ["a", "b", "c", "d", "e", "f", "g", "h"]
d = random.choice(L)
# random.sample(sequence,count)从指定序列中获取指定个数的随机元素。sample函数不会修改原有序列。
e = random.sample(L, 2)
# random.randrange([start], stop[, step])从指定范围内，按指定基数递增的集合中获取一个随机数。
f = random.randrange(1, 10)
# random.shuffle(list)将一个列表内的元素顺序打乱，随机排列
g = random.sample([1, 2, 3, 4, 5], 3)
print(x, y, z, d, e, f, g)

0.19552449420165796 3.7043231980895923 5 c ['a', 'g'] 7 [5, 1, 4]

0.641033571920274 2.687916844965531 1 e ['e', 'a'] 6 [2, 5, 3]

（6）布尔变量

bool()函数允许您评估任何值，并给您 True或False 作为返回。True如果它具有某种内容，几乎任何值都会被评估。任何字符串都是True，空字符串除外。任何数字都是True，除了 0。任何列表、元组、集合和字典都是True，空的除外。

print( bool( "a"))#True

·布尔假值

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

全为False

·isinstance() 函数

Python 也有许多返回布尔值的内置函数，如 isinstance() 函数，可用于确定对象是否属于某种数据类型

检查对象是否为整数：

x = 200

print( isinstance(x, int))

True

·直接判断

print(10 > 9)#True

算数运算符

·除法

/返回为float,//返回整数，%返回余数

a=15/4
b=10/3
c=10//3
d=10%3
print(a,b,c,d)

3.75 3.3333333333333335 3 1

·幂运算（**）

a=2**3
print(a)#8

a=8
a>>=3
print(a)#1

列表list

·第一种方法，列表是使用方括号创建的：

mylist = [
    "一号",
    "二号",
    "三号"]

·第二种方法，创建新列表时也可以使用 list() 构造函数。

thislist = list((
    "apple",
    "banana",
    "cherry"))

·允许重复
由于列表已编入索引，因此列表可以包含具有相同值的项目。列表项是有序的、可变的，并允许重复值。列表项可以被索引，第一项有索引[0]，第二项有索引[1]等等。（thislist[0]可以索引到apple）

·负索引

负索引意味着从头开始，-1指最后一项， -2指倒数第二项等。

thislist[-1]可以索引到cherry

·索引范围

print(mylist[0:2])

['一号', '二号']

·检查是否存在

要确定列表中是否存在指定的项目，请使用in关键字。

if "apple" in thislist:
print("Yes")#yes

·更改

单个位置的更改用索引值：mylist[ 0]= "0号"

多个位置的更改用范围表示：mylist[ 1: 2]=[ "1号", "2号"]

·插入

insert()方法在指定的索引处插入一个项目。

mylist.insert( 2, 'inset')#插入内容的索引变为2

·添加

要将值添加到列表的末尾，请使用append() 方法：

mylist. append( "3号")

·合并列表

要将另一个列表中的元素附加到当前列表，请使用extend()方法。

mylist = [
    "一号",
    "二号",
    "三号"]
thislist = list((
    "apple",
    "banana",
    "cherry"))
thislist.extend(mylist)
print(thislist)

['apple', 'banana', 'cherry', '一号', '二号', '三号']

extend()方法不一定要列表，您也可以添加任何可迭代对象（元组、集合、字典等）。

thislist = list((
    "apple",
    "banana",
    "cherry"))
yuan=(
    "1",
    "2",
    "3"
)
mylist.extend(yuan)
print(mylist)

['一号', '二号', '三号', '1', '2', '3']

·删除指定项

remove()方法删除指定的项目。

mylist.remove( '1号')

·删除指定索引

pop()方法删除指定的索引。如果不指定索引，该pop()方法将删除最后一项。

mylist.pop( 2)

·del删除指定的索引

del mylist[ 0]

del关键字也可以完全删除列表：del mylist

·清除列表

clear()方法清空列表。该列表仍然存在，但没有内容。

mylist.clear()#[]

·循环列表

第一种方法可以使用：for i in mylist

第二种方法可以使用：for i in range( len(mylist)):

·列表推导式

选择含有特定内容的创建新的列表

fruits = [

"apple",

"banana",

"cherry",

"kiwi",

"mango"]

newlist = []

for x in fruits:

if "a" in x:

newlist.append(x)

将上述代码用列表推导式表达：

fruits = [
     "apple",
     "banana",
     "cherry",
     "kiwi",
     "mango"]
newlist = [x
     for x in fruits
     if "a" in x]

·区分大小写的列表排序

默认情况下，该sort()方法区分大小写，导致所有大写字母都排在小写字母之前：

thislist. sort()

·不区分大小写的排序

如果你想要一个不区分大小写的排序函数，使用 str.lower 作为键函数：

thislist. sort(key = str. lower)

·倒序

reverse()方法反转元素的当前排序顺序。

mylist. reverse()

·复制列表

第一种方法，copy()方法制作列表的副本：my = mylist.copy()

第二种方法，list()方法制作列表的副本：my = list(mylist)

·加入列表

第一种最简单的方法之一是使用+ 运算符。

list1 = [

"a",

"b",

"c"]

list2 = [

list3 = list1 + list2

第二种方法extend() 方法，其目的是将元素从一个列表添加到另一个列表：list1.extend(list2)

·遍历列表

for i in mylist:
print(i)

·列表长度

print(len(thislist))

·列表项 - 数据类型

列表项可以是任何数据类型。

list1 = [
    "apple",
    "banana",
    "cherry"]

list2 = [
    1,
    5,
    7,
    9,
    3]

list3 = [
    True,
    False,
    False]
print(list1, list2, list3)