Call method in python file

How to call a method from a different file without importing it in python

Example: MainLibrary.py file: SecondaryLibrary.py file «The old scripts will recieve the values for paramters «a and b» and C will be always 0″ But, with the new requirements, i need to compute the value of C based on the values of a and b — all the computation part are handled in xy method» Note: I dont have permission to edit the MainLibrary file or the Scripts, everything has to be handled in the SecondaryLibrary file Script: Solution: You can construct a class in your script to do what you require; For example, in the first iteration (initiated from main.py), originalBody.py will look like: in second iteration, originalBody.py will automatically look like: When I’m trying to call the class from main.py, main.py in the first iteration it runs smoothly: In the second iteration, after adding the body segment to originalBody.py, supposedly the result is expected to print out: However, it prints out the result from the first iteration: I suspect that my code calls the function from the original version of originalBody.py that has not modified yet.

How to call a method from a different file without importing it in python

1. MainLibrary.py — All the important methods are available in this file
2. SecondaryLibrary.py — specific methods are available in this file, which cannot be placed in the MainLibrary.py file

There are old scripts which only imports the MainLibrary and does not import the SecondayLibrary file. Here, when these old scripts are called — instead of accessing the methods from the mainlibrary file, is it possible to access the methods from the secondaryLibrary file without changing anything in the scripts or MainLibrary file.

class MainLibrary: def x(self, a =0, b=0, c= 0): """ Do some operation with these values""" def y(self, a=0,b=0,c=0): """Do some operation with these values""" 

class SecondaryLibrary: def xy(self, a=0, b=0, c=0): """Compute the value of C based on the values of a and b and then do some operation""" 

«The old scripts will recieve the values for paramters «a and b» and C will be always 0″ But, with the new requirements, i need to compute the value of C based on the values of a and b — all the computation part are handled in xy method»

Note: I dont have permission to edit the MainLibrary file or the Scripts, everything has to be handled in the SecondaryLibrary file

from MainLibrary import * obj = MainLibrary() "get the values of a and b" obj.x(a,b) Here when method X is called --> i need to call method "xy" from the sceondaryLibrary file. 

You can construct a class in your script to do what you require;

# MainLibrary.cs class MainLibrary(object): def x(self, a, b, c): return a + b + c def y(self, a, b, c): return a * b * c # SecondaryLibrary.cs class SecondaryLibrary(object): def xy(self, a, b,c ): return c - a - b # Script.cs from MainLibraryimport MainLibrary from SecondaryLibrary import SecondaryLibrary class Script(MainLibrary, SecondaryLibrary): def x(self, a, b, c): # As in your question this is how we specify that calling # obj.x should return the result of .xy return super().xy(a, b, c) def y(self, a, b, c): return super().y(a, b, c) if __name__ == '__main__': obj = Script() result = obj.x(1, 2, 5) print(result) # gives 5 - 2 - 1 => 2 

How to include external Python code to use in other files?, I would like to emphasize an answer that was in the comments that is working well for me. As mikey has said, this will work if you want to have variables in the included file in scope in the caller of ‘include’, just insert it as normal python. It works like an include statement in PHP. Works in Python 3.8.5. …

Python — How do I call class method from another newly modified python file

I’m new in python programming and would like to seek help in calling a method from another newly modified python file.

I currently have 3 python files: main.py, addBody.py, and originalBody.py.

The addBody will add one segment of the body to originalBody.py in each iteration. This is done by read and write function.

in the first iteration (initiated from main.py), originalBody.py will look like:

class BODY: def __init__(self): object1 = send_cylinder(length = 1.0, radius = 0.1) bodySegment = <> bodySegment[0] = 1 #one body 

in second iteration, originalBody.py will automatically look like:

class BODY: def __init__(self): object1 = send_cylinder(length = 1.0, radius = 0.1) object2 = send_cylinder(length = 1.0, radius = 0.1) bodySegment = <> bodySegment[0] = 1 #one body bodySegment[1] = 2 #two body 

When I’m trying to call the class from main.py,

from originalBody import BODY for i in range (0,10): fileToRead = open('addBody.py') fileToAppend = open('originalBody.py', 'a') . (add body from addBody.py to originalBody.py). fileToAppend.close() fileToRead.close() parent = BODY() print(parent.bodySegment) 

in the first iteration it runs smoothly:

In the second iteration, after adding the body segment to originalBody.py, supposedly the result is expected to print out:

However, it prints out the result from the first iteration:

I suspect that my code calls the function from the original version of originalBody.py that has not modified yet. Do I need to add in some code in my main to get the class method from the modified version of originalBody? Or do I need to add in time delay to call the method right after the modification of originalBody?

You can reload a module when it has already been imported by using the reload builtin function.

I edited your code using import originalBody because I am not sure how the reload function works with the from x import y syntax.

from importlib import reload import originalBody for i in range (0,10): reload(originalBody) fileToRead = open('addBody.py') fileToAppend = open('originalBody.py', 'a') . (add body from addBody.py to originalBody.py). fileToAppend.close() fileToRead.close() parent = originalBody.BODY() print(parent.bodySegment) 

Pandas — How to call a function from another file in Python, I’m writing a Airflow DAG that uses a PythonOperator. It requires a «python_callable» which it seems to be a function. I’m calling this Python code dag-transf.py. I have a Python code that does some transformation through pandas (transf.py) I need dag-transf.py task to execute transf-py as the …

Calling Method from Different Python File

As I’m currently learning Django / Python, I’ve not really been using the concept of Classes, yet. As far as I’m aware the method isn’t static.. it’s just a standard definition.

So let’s say I have this Package called Example1 with a views.py that contains this method:

Then I have an Example2 which also has a views.py where I’d like to use this method adder .

How would I got about doing this?

EDIT: In Java it would be a simple instantiation then a instantiation.Method() or if it was static it would be SomeClass.Method() however I’m unsure how I should approach this in Python.

Python has module level and class level methods. In this concept a «module» is a very special class that you get by using import instead of Name() . Try

from Example1.views import adder as otherAdder 

to get access to the module level method. Now you can call otherAdder() and it will execute the code in the other module. Note that the method will be executed in the context of Example1.views , i.e. when it references things, it will look there.

from Example2.views import adder as myadder myadder(x,y) 

If you are unsure, you can always start a python shell and then use the dir command to look inside the contents of packages to see what can be used.

Edit: Updated from comments to use ‘as’

# use . views as myviews if you need to avoid name conflict on views from Example2 import views views.adder(x,y) 

Normally you import «modules»

from Example2 import views as views2 x = views2.adder(1, 2) 

I hope, I got this right, since I did not use packages till now 😉

Python: How to Call a function in another file with a, I am making a text-based floor game for learning purposes. I want all of the moving-around functions to be in a separate python file but I am having issues getting them to work together. I have the main game called floors.py and the map file is floormap.py. I can import and run functions from floormap.py inside …

Источник

Python – call a function from another file

As a Python programmer, you may want to call a function from another file in Python. By doing so, you do not have to rewrite your code or copy it into your existing code base.

We will use Python 3.10.4 with Visual Studio Code as our code editor for this guide. But, of course, you are free to use the code editor of your choice.

Scripts, Functions, and Methods – a quick recap

Learning exactly what scripts, functions, and methods mean can simplify the process of calling a function from another file in Python.

• Every time you write Python code, you are writing a script. These scripts are then executed in Python Shell, and you get the output.
• Functions are reusable codes that you can use when coding. This simplifies your approach to coding apps or websites.
• Lastly, we have methods included in packages such as Numpy, Matplotlib, etc. These methods are pre-defined and provide the functions used on Python objects.

Step 1: Create a script with functions

The first step is to create a script with functions. You can skip to the second step if you have already created a script.

For this tutorial, we will create file.py which contains four functions: addition(), subtract(), multiply() and Hello_world().

The code for it is as below.

#here we create a function that we want to call from another file def addition(a,b): #code for adding return a +b def Hello_World(): #Hi world! return "Hello, World!" def subtract(a,b): if a > b: return a - b else: return b - a def multiply(a,b): return a * b;

Step 2: Create the file you want to call the function from

Next, we need to create another script where we call functions from the first file. Let’s name the new script file2.py.

#import everything from file.py from file import * #storing Hello_world() return value to world variable world = Hello_World() #print world varaible to the screen print(world) 

from file import * tells the compiler to import all the available functions in file.py.

Next, we call Hello_World() function defined in file.py and print its value to the screen.

You can also import the functions by assigning them a variable and then accessing it through it.

And to access the functions, you need to use the following notation.

Step 3: Call selected functions

Similarly, you can call other functions in file2.py from file.py.

Let’s look at another example, but this time, we will import selected functions. Let’s name this script: file3.py

#importing selected functions from file.py from file import addition, subtract #using the addition function to add two numbers add_result = addition(3,5) #using the substract function to subtract two numbers sub_result = subtract(5,3) #printing out result print(add_result) print(sub_result)

To import selected functions, you need to separate them using a comma, as shown in the line from file import addition, subtract

The output is shown below.

Things to keep in mind when calling functions

You can import multiple functions from different files as well.

If you are importing functions from a file not in the same folder, you need to use the exact path from the root directory.

So, if you have your file.py inside two directories, you must import it using the following command.

from rootfolder.folder1.folder2.file import addition, subtract

That’s it! You have successfully learned how to call a function from another file in Python.

Источник